dbAccessor 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4a41358d7b31fa18301d319fb3c36551ca9aff86
-  data.tar.gz: f71da5be6755d7d1b56a34713530c958a3a501ac
+  metadata.gz: b880eb3b9ef4c01a57315c4b04b50bf3ca90dd7d
+  data.tar.gz: 1fc7cca67db5273802dea1010b932e7582c0281c
 SHA512:
-  metadata.gz: 2a681cbec809a0b117631dad40ca02201f6d3c6244b2fcc5e84436f6670a0b59262581bf3ecdde9cf644735f294a3a1b5678b36c1bc672b7b4e587b5621c7e05
-  data.tar.gz: 1ba240a0cc60456647e82bba6da60c4b33cde3c7f55759748a7eaf467dd7af6b36f9904f80ea15bb3e654078180c4a0f0c623c91f6a170c94d809d46fb4c6276
+  metadata.gz: 6603078e3d289a6a5a02d1a08e879ffbd5a290766b8e90599531df582b3c075f8fa4d399fa8b472af84d5d2554d7aedc960feb241ad018228f12192a7bcfdc94
+  data.tar.gz: 32a808da4e3bf5fc7dcb4b1aff528dd592c9f45e53b464d1084fdde2619aa546e146dc5d3c024446b0d3537df89824eb0cdbb77e958e211f92e40f3d8f84ec9a

data/lib/dbAccessor/base.rb

@@ -1,18 +1,14 @@
 module Db_Accessor
-  
   class Base
-    USER_MODEL   = 'User'
-    APP_MODEL    = 'Application'
-    ENGINE_MODEL = 'Engine'
+    USER_MODEL        = 'User'
+    APP_MODEL         = 'Application'
+    ENGINE_MODEL      = 'Engine'
     ENGINE_DATA_MODEL = 'Engine_data'
-    ACTION_MODEL = 'Action'
-    ASSIGNMENT_MODEL = 'Assignment'
-  
-      
+
     def self.validate_argument(given_param)
       resp = nil
       given_param.values.each do |v|
-        if v.nil? 
+        if v.nil?
           resp = true
           break
         elsif v.is_a?(String) && v.empty?
@@ -34,7 +30,7 @@ module Db_Accessor
     end
 
     def self.is_model?(param)
-      model = [ USER_MODEL, APP_MODEL, ENGINE_MODEL, ENGINE_DATA_MODEL,ACTION_MODEL,ASSIGNMENT_MODEL]
+      model = [ USER_MODEL, APP_MODEL, ENGINE_MODEL, ENGINE_DATA_MODEL ]
       model.include?(param)
     end
 
@@ -42,8 +38,7 @@ module Db_Accessor
       param.is_a?(Hash)
     end
 
-   
-  def self.valid_keys?(param,waited_keys)
+    def self.valid_keys?(param,waited_keys)
       waited_keys.each do |k|
         if !(param.has_key?(k))
           return false
@@ -51,9 +46,9 @@ module Db_Accessor
         end
       end
       return true
-  end
+    end
 
-  def self.verify_keys(keys,attributes)
+    def self.verify_keys(keys,attributes)
      keys.each do |k|
       if !(attributes.include?(k))
         return false
@@ -61,31 +56,27 @@ module Db_Accessor
       end
     end
     return true
-  end
+    end
 
-  def self.valid_object_columns?(model_name,content)
-    engine_columns = [:id,:name,:application_id]
-    engine_data_columns = [:id,:customer_id,:item_id,:preference,:engine_id]
-    action_columns = [:id,:name,:score]
-    assignment_columns = [:id,:engine_id,:action_id]
-    app_columns  = [:id,:name,:api_key,:url,:user_id]
-    user_columns = [:id,:login,:password,:firstname,:lastname,:gender,:email]
- 
-    keys = content.keys 
-    if model_name == "User" 
-       attributes = user_columns 
-    elsif model_name == "Application"
-       attributes = app_columns
-    elsif model_name == "Engine"
+    def self.valid_object_columns?(model_name,content)
+      engine_columns      = [:id,:engine_conf,:application_id]
+      engine_data_columns = [:id,:customer_id,:item_id,:preference,:engine_id]
+      app_columns         = [:id,:name,:api_key,:url,:user_id]
+      user_columns        = [:id,:login,:password,:firstname,:lastname,:gender,:email]
+
+      keys = content.keys
+      if model_name == "User"
+        attributes = user_columns
+      elsif model_name == "Application"
+        attributes = app_columns
+      elsif model_name == "Engine"
         attributes = engine_columns
-    elsif model_name == "Engine_data"
+      else
         attributes = engine_data_columns
-    else
-        attributes = action_columns
+      end
+
+      verify_keys(keys,attributes)
     end
-    
-    verify_keys(keys,attributes)
-  end
 
    def self.valid_class?(keys,columns,attributes)
      keys.each do |k|
@@ -111,10 +102,5 @@ module Db_Accessor
     valid_class?(keys,string_columns,attributes)
   end
 
-
-
-
-
-  end
-
+end
 end

data/lib/dbAccessor/reader/reader.rb

@@ -3,48 +3,44 @@ require_relative '../base'
 
 class DbAccessor::Reader < Db_Accessor::Base
 
-  
+
   def self.simple_select(given_param)
     waited_keys = [:model_name,:action_on]
     if validate(given_param,waited_keys)
-     result = get_model_name(given_param).where(deleted: false).send(given_param[:action_on])
-	 result.nil? ?  return_response(404,"Not found") : return_response(200,result)
+      result = get_model_name(given_param).where(deleted: false).send(given_param[:action_on])
+      result.nil? ?  return_response(404,"Not found") : return_response(200,result)
     else
-        return_response(404,"Not found")
+      return_response(404,"Not found")
     end
-    rescue ActiveRecord::RecordNotFound => e
-	 return_response(404,"Not found")
+  rescue ActiveRecord::RecordNotFound => e
+    return_response(404,"Not found")
   end
-	
- 
+
   def self.condition_select(given_param)
     waited_keys = [:model_name,:condition]
-    if validate(given_param,waited_keys) 
-     result = get_model_name(given_param).where(given_param[:condition],deleted: false)
-     ( result.nil? || result == []) ? return_response(404,"Not found") : return_response(200,result)
+    if validate(given_param,waited_keys)
+      result = get_model_name(given_param).where(given_param[:condition],deleted: false)
+      ( result.nil? || result == []) ? return_response(404,"Not found") : return_response(200,result)
     else
       return_response(404,"Not found")
     end
-    rescue ActiveRecord::RecordNotFound => e
-	 return_response(400,"Not found")
+  rescue ActiveRecord::RecordNotFound => e
+    return_response(400,"Not found")
   end
 
-
   def self.select_by_id(given_param)
     waited_keys = [:model_name,:identifiers]
     if validate(given_param,waited_keys) && validate_id(given_param[:identifiers])
       model_name = get_model_name(given_param)
-      result     = model_name.where(deleted: false).where(id: given_param[:identifiers])  
+      result     = model_name.where(deleted: false).where(id: given_param[:identifiers])
       result.nil? ? return_response(404,"Not found") : return_response(200,result)
     else
       return_response(404,"Not found")
     end
-    rescue ActiveRecord::RecordNotFound => e
-	 return_response(404,"Not found")
+  rescue ActiveRecord::RecordNotFound => e
+    return_response(404,"Not found")
   end
 
-
-
   def self.linked_models_select(given_param)
     waited_keys = [:model_name,:condition,:models]
     if validate(given_param,waited_keys)
@@ -52,30 +48,30 @@ class DbAccessor::Reader < Db_Accessor::Base
       condition  = given_param[:condition]
       models     = given_param[:models]
       result     = model_name.where(condition,deleted: false).first
-      result.nil? ? return_response(404,"Not found") : return_response(200,result.send(models)) 
+      result.nil? ? return_response(404,"Not found") : return_response(200,result.send(models))
     else
       return_response(404,"Not found")
     end
-    rescue ActiveRecord::RecordNotFound => e
-	 return_response(400,"Not found")
-  end 
-private ##################################################################
+  rescue ActiveRecord::RecordNotFound => e
+    return_response(400,"Not found")
+  end
+  private ##################################################################
 
   def self.validate(param,waited_keys)
-    valid_hash?(param) && valid_keys?(param,waited_keys) && !validate_argument(param) && is_model?(param[:model_name]) 
+    valid_hash?(param) && valid_keys?(param,waited_keys) && !validate_argument(param) && is_model?(param[:model_name])
   end
- 
+
   def self.validate_id(param)
-       test_id = lambda do |param|
-                   param.each do |i| 
-                     if !(i.is_a?(Fixnum))
-                       return false
-                       break
-                     end
-                   end
-                   return true
-                 end
-       param.is_a?(Array) && test_id.call(param)
+    test_id = lambda do |param|
+      param.each do |i|
+        if !(i.is_a?(Fixnum))
+          return false
+          break
+        end
+      end
+      return true
+    end
+    param.is_a?(Array) && test_id.call(param)
   end
 
-  end
+end

data/lib/dbAccessor/updater/updater.rb

@@ -1,9 +1,9 @@
 require_relative '../../../spec/feed/resources/environment'
 require_relative '../base'
 
-class DbAccessor::Updater < Db_Accessor::Base 
+class DbAccessor::Updater < Db_Accessor::Base
+
 
-  #updates given object(s) with given attributes using object's identifier named 'id'
   def self.update_by_id(given_object)
     waited_keys = [:model_name,:attributes]
     if validate(given_object,waited_keys) && valid_attributes_pattern?(given_object[:model_name],given_object[:attributes])
@@ -16,7 +16,7 @@ class DbAccessor::Updater < Db_Accessor::Base
 	 return_response(400,"Not updated")
   end
 
-  #updates all model's objects or model's objects that satisfy the given condition with given attributes 
+
   def self.update_all_objects(given_param,condition="")
     waited_keys = [:model_name,:attributes]
     if validate(given_param,waited_keys) && valid_object_columns?(given_param[:model_name],given_param[:attributes]) && valid_attributes_values?(given_param[:attributes])
@@ -30,8 +30,8 @@ class DbAccessor::Updater < Db_Accessor::Base
         result = update_by_id(hash)
         break if !result
       end
-	  result ? return_response(200,"Successfully updated") : return_response(400,"Not updated") 
-    else 
+	  result ? return_response(200,"Successfully updated") : return_response(400,"Not updated")
+    else
   	  return_response(400,"Not updated")
     end
   end
@@ -45,8 +45,8 @@ class DbAccessor::Updater < Db_Accessor::Base
   def self.validate_attributes(given_param)
     given_param.is_a?(Hash) && !given_param.empty?
   end
-  
- 
+
+
   def self.valid_fixnum_keys?(keys)
     keys.each do |k|
       if !(k.is_a?(Fixnum))
@@ -59,7 +59,7 @@ class DbAccessor::Updater < Db_Accessor::Base
 
   def self.valid_values_pattern?(values,model_name)
     values.each do |v|
-       if !(v.nil?)  
+       if !(v.nil?)
          if v.empty? || !(v.is_a?(Hash)) || !valid_object_columns?(model_name,v) || !valid_attributes_values?(v)
          return false
          break
@@ -81,7 +81,7 @@ class DbAccessor::Updater < Db_Accessor::Base
   end
 
   def self.validate(param,waited_keys)
-    param.is_a?(Hash) && valid_keys?(param,waited_keys) && is_model?(param[:model_name]) && validate_attributes(param[:attributes]) && !validate_argument(param) 
+    param.is_a?(Hash) && valid_keys?(param,waited_keys) && is_model?(param[:model_name]) && validate_attributes(param[:attributes]) && !validate_argument(param)
   end
 
 end

data/lib/dbAccessor/version.rb

@@ -1,3 +1,3 @@
 module DbAccessor
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

data/lib/dbAccessor/writer/writer.rb

@@ -3,8 +3,10 @@ require_relative '../base'
 
 class DbAccessor::Writer < Db_Accessor::Base
 
-  USER_MODEL = 'User'
-  APP_MODEL  = 'Application'
+  USER_MODEL        = 'User'
+  ENGINE_MODEL      = 'Engine'
+  ENGINE_DATA_MODEL = 'Engine_data'
+  APP_MODEL         = 'Application'
 
   def self.write_object(object_param)
     waited_keys =[:model_name,:content]
@@ -12,14 +14,13 @@ class DbAccessor::Writer < Db_Accessor::Base
       @given_object = get_object(object_param)
       @given_object.save
       !@given_object.new_record? ? code = 201 : code = 400
-      return_response(code,"Success") 
+      return_response(code,"Success")
     else
        return_response(400,"Failed")
     end
   end
 
 private ######################################################################
-
   def self.get_content(object_param)
     object_param[:content]
   end
@@ -27,47 +28,30 @@ private ######################################################################
   def self.get_object(object_param)
     get_model_name(object_param).new(get_content(object_param))
   end
- 
+
   def self.validate_required_params(param)
       content = param[:content]
       model_name = param[:model_name]
-      if model_name == 'User'
+      if model_name == USER_MODEL
       email_pattern = /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i
-      content[:login].is_a?(String) && content[:password].is_a?(String) && content[:email].is_a?(String) && !(email_pattern.match(content[:email])).nil? 
-      elsif model_name == 'Application'
+      content[:login].is_a?(String) && content[:password].is_a?(String) && content[:email].is_a?(String) && !(email_pattern.match(content[:email])).nil?
+
+      elsif model_name == APP_MODEL
           content[:name].is_a?(String) && content[:api_key].is_a?(String) && content[:url].is_a?(String)
-      elsif model_name == 'Engine'
-          content[:name].is_a?(String) && content[:application_id].is_a?(Fixnum)
+
+      elsif model_name == ENGINE_MODEL
+          content[:engine_conf].is_a?(String) && content[:application_id].is_a?(Fixnum)
+
+      elsif model_name == ENGINE_DATA_MODEL
+          content[:customer_id].is_a?(Fixnum) && content[:item_id].is_a?(Fixnum) && content[:preference].is_a?(Fixnum) && content[:engine_id].is_a?(Fixnum)
       else
           false
       end
   end
 
-   
   def self.validate(param,waited_keys)
    valid_hash?(param) && valid_keys?(param,waited_keys) && is_model?(param[:model_name]) && valid_object_columns?(param[:model_name],param[:content]) && !validate_argument(param) && !validate_argument(param[:content]) && validate_required_params(param)
 
   end
-
-
-
- end 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+ end
 

data/spec/deleter_spec.rb

@@ -1,90 +1,90 @@
 require_relative 'spec_helper'
 
-describe DbAccessor::Deleter do	
+describe DbAccessor::Deleter do
 
   describe ".delete_all" do
-	given_param = { model_name: "User",condition: {id: 3}}
+    given_param = { model_name: "User",condition: {id: 3}}
     context "when the object is deleted" do
-		it {expect((DbAccessor::Deleter.delete_all(given_param))[:code]).to eq 200 }
+      it {expect((DbAccessor::Deleter.delete_all(given_param))[:code]).to eq 200 }
 
-		it {expect((DbAccessor::Deleter.delete_all({model_name: "Application",condition: {name: 'Wikia'}}))[:code]).to eq 200 }
-      
-		it {expect((DbAccessor::Deleter.delete_all({model_name: "User",condition: {login: 'fabira',password: 'passera'}}))[:code]).to eq 200 }
-	end
+      it {expect((DbAccessor::Deleter.delete_all({model_name: "Application",condition: {name: 'Wikia'}}))[:code]).to eq 200 }
+
+      it {expect((DbAccessor::Deleter.delete_all({model_name: "User",condition: {login: 'fabira',password: 'passera'}}))[:code]).to eq 200 }
+    end
 
     context "when the conditon format is not valid" do
-        param = {model_name: "User",condition: {ta: 1}}
+      param = {model_name: "User",condition: {ta: 1}}
 
-		it {expect((DbAccessor::Deleter.delete_all(param))[:code]).to eq 400 }
+      it {expect((DbAccessor::Deleter.delete_all(param))[:code]).to eq 400 }
 
-        param[:condition] = "coucou"
-		it {expect((DbAccessor::Deleter.delete_all(param))[:code]).to eq 400 }
+      param[:condition] = "coucou"
+      it {expect((DbAccessor::Deleter.delete_all(param))[:code]).to eq 400 }
 
-        param[:condition] = nil
-		it {expect((DbAccessor::Deleter.delete_all(param))[:code]).to eq 400 }
+      param[:condition] = nil
+      it {expect((DbAccessor::Deleter.delete_all(param))[:code]).to eq 400 }
 
-        param[:condition] = {login: 1}
-		it {expect((DbAccessor::Deleter.delete_all(param))[:code]).to eq 400 }
+      param[:condition] = {login: 1}
+      it {expect((DbAccessor::Deleter.delete_all(param))[:code]).to eq 400 }
 
-        param[:model_name] = "Application"
-        param[:condition] = {login: 'fabi'}
-		it {expect((DbAccessor::Deleter.delete_all(param))[:code]).to eq 400 }
-	end
+      param[:model_name] = "Application"
+      param[:condition] = {login: 'fabi'}
+      it {expect((DbAccessor::Deleter.delete_all(param))[:code]).to eq 400 }
+    end
 
     context "when model name is invalid" do
-		it {expect((DbAccessor::Deleter.delete_all({model_name: "A",condition: {}}))[:code]).to eq 400 }
-	end
+      it {expect((DbAccessor::Deleter.delete_all({model_name: "A",condition: {}}))[:code]).to eq 400 }
+    end
 
     context "when one of the parameter's keys is invalid" do
-		it {expect((DbAccessor::Deleter.delete_all({model: "User",condition: {}}))[:code]).to eq 400 }
-	end
+      it {expect((DbAccessor::Deleter.delete_all({model: "User",condition: {}}))[:code]).to eq 400 }
+    end
 
-	context "when the object which satisfy the given condition is deleted" do
-		it {expect((DbAccessor::Deleter.delete_all({model_name: "User",condition: {id: 4}}))[:code]).to eq 200 }
+    context "when the object which satisfy the given condition is deleted" do
+      it {expect((DbAccessor::Deleter.delete_all({model_name: "User",condition: {id: 4}}))[:code]).to eq 200 }
+
+      it {expect((DbAccessor::Deleter.delete_all({model_name: "Application",condition: {id: 4}}))[:code]).to eq 200 }
+    end
 
-		it {expect((DbAccessor::Deleter.delete_all({model_name: "Application",condition: {id: 4}}))[:code]).to eq 200 }	
-	end
-  
     context "when one or many parameters are empty or nil" do
-        it {expect((DbAccessor::Deleter.delete_all({model_name: nil,condition: {id: 3}}))[:code]).to eq 400 }
+      it {expect((DbAccessor::Deleter.delete_all({model_name: nil,condition: {id: 3}}))[:code]).to eq 400 }
     end
 
   end
 
   describe ".delete_by_id" do
-      context "when the object find by id is deleted" do
+    context "when the object find by id is deleted" do
       given_param={model_name: "Application", id: [4]}
-	  it {expect((DbAccessor::Deleter.delete_by_id(given_param))[:code]).to eq 200 }
+      it {expect((DbAccessor::Deleter.delete_by_id(given_param))[:code]).to eq 200 }
 
       given_param={model_name: "User", id: [4]}
-	  it {expect((DbAccessor::Deleter.delete_by_id(given_param))[:code]).to eq 200 }
-	end 
+      it {expect((DbAccessor::Deleter.delete_by_id(given_param))[:code]).to eq 200 }
+    end
 
     context "when the id's format is invalid" do
       given_param={model_name: "User", id: "coucou"}
-	  it {expect((DbAccessor::Deleter.delete_by_id(given_param))[:code]).to eq 400 }
-	end 
+      it {expect((DbAccessor::Deleter.delete_by_id(given_param))[:code]).to eq 400 }
+    end
 
 
-    context "when one or many parameters are empty or nil" do 
-        given_param={model_name: "User", id: nil}
-        it {expect((DbAccessor::Deleter.delete_by_id(given_param))[:code]).to eq 400 }
+    context "when one or many parameters are empty or nil" do
+      given_param={model_name: "User", id: nil}
+      it {expect((DbAccessor::Deleter.delete_by_id(given_param))[:code]).to eq 400 }
     end
 
-    context "when the model name is invalid" do 
-        given_param={model_name: "U3466", id: [1,2,3]}
-        it {expect((DbAccessor::Deleter.delete_by_id(given_param))[:code]).to eq 400 }
+    context "when the model name is invalid" do
+      given_param={model_name: "U3466", id: [1,2,3]}
+      it {expect((DbAccessor::Deleter.delete_by_id(given_param))[:code]).to eq 400 }
     end
 
-    context "when parameter's keys are invalid" do 
-        given_param={model_name: "User", i: [1,2] }
-        it {expect((DbAccessor::Deleter.delete_by_id(given_param))[:code]).to eq 400 }
-        given_param = {model: "Application",id: [3]} 
-        it {expect((DbAccessor::Deleter.delete_by_id(given_param))[:code]).to eq 400 }
+    context "when parameter's keys are invalid" do
+      given_param={model_name: "User", i: [1,2] }
+      it {expect((DbAccessor::Deleter.delete_by_id(given_param))[:code]).to eq 400 }
+      given_param = {model: "Application",id: [3]}
+      it {expect((DbAccessor::Deleter.delete_by_id(given_param))[:code]).to eq 400 }
     end
 
-    context "when the parameter is nil" do  
-        it {expect((DbAccessor::Deleter.delete_by_id(nil))[:code]).to eq 400 }
+    context "when the parameter is nil" do
+      it {expect((DbAccessor::Deleter.delete_by_id(nil))[:code]).to eq 400 }
     end
   end
 end

data/spec/feed/dbTest/migration/create_table_actions.rb

@@ -2,18 +2,18 @@
 class CreateActions < ActiveRecord::Migration
   def self.up
     create_table :actions do |a|
-      a.string  :name 
+      a.string  :name
       a.integer :score
       a.timestamps
-    end 
-  end 
-  
+    end
+  end
+
   def self.down
     drop_table :actions
   end
 end
 
 CreateActions.down
-CreateActions.up
+
 
 

data/spec/feed/dbTest/migration/create_table_assignments.rb

@@ -2,18 +2,18 @@
 class CreateAssignments < ActiveRecord::Migration
   def self.up
     create_table :assignments do |a|
-      a.integer  :engine_id 
+      a.integer  :engine_id
       a.integer  :action_id
       a.timestamps
-    end 
+    end
 
     add_index :assignments, :engine_id
     add_index :assignments,  :action_id
-  end 
-  
+  end
+
   def self.down
     drop_table :assignments
   end
 end
 
-CreateAssignments.up
+CreateAssignments.down

data/spec/feed/dbTest/migration/create_table_engine_data.rb

@@ -15,5 +15,5 @@ class CreateEngineData < ActiveRecord::Migration
   end
 
 end
-
+CreateEngineData.down
 CreateEngineData.up

data/spec/feed/dbTest/migration/create_table_engines.rb

@@ -1,7 +1,7 @@
 class CreateEngines < ActiveRecord::Migration
     def self.up
       create_table :engines do |e|
-        e.string     :name 
+        e.column     :engine_conf, :json
         e.integer    :application_id
         e.timestamps
       end

data/spec/feed/dbTest/model/engine.rb

@@ -1,14 +1,11 @@
 require 'active_record'
 require_relative 'engine_data'
 require_relative 'application'
-require_relative 'action'
-require_relative 'assignment'
 
 class Engine < ActiveRecord::Base
 
-  validates_presence_of :name 
+  validates_presence_of :engine_conf
   has_one               :engine_data
   belongs_to            :application
-  has_many              :actions, through: :assignments
 
 end

data/spec/reader_spec.rb

@@ -2,11 +2,12 @@ require_relative 'spec_helper'
 
 
 describe DbAccessor::Reader do
-  
+
   describe ".simple_select" do
     context "when all model's items are found" do
       it {expect((DbAccessor::Reader.simple_select({model_name: "User",action_on: "all"}))[:code]).to eq 200 }
-	end		
+      it {expect((DbAccessor::Reader.simple_select({model_name: "Engine",action_on: "all"}))[:code]).to eq 200 }
+	  end
     context "when the first model's item is found" do
       it {expect((DbAccessor::Reader.simple_select({model_name: "User",action_on: "first"}))[:code]).to eq 200 }
     end
@@ -18,7 +19,7 @@ describe DbAccessor::Reader do
     context "when it reads many items according to the condition" do
         it {expect((DbAccessor::Reader.simple_select({model_name: "User",action_on: nil}))[:code]).to eq 404 }
     end
-		
+
     context "when passed parameter's keys are not correct" do
         it {expect((DbAccessor::Reader.simple_select({model: "User",action: nil}))[:code]).to eq 404 }
     end
@@ -39,8 +40,8 @@ describe DbAccessor::Reader do
     end
 
     context "when condition is not correct" do
-      it {expect((DbAccessor::Reader.condition_select({model_name: "", condition: 1 }))[:code]).to eq 404 } 
- 
+      it {expect((DbAccessor::Reader.condition_select({model_name: "", condition: 1 }))[:code]).to eq 404 }
+
       it {expect((DbAccessor::Reader.condition_select({model_name: "", condition: "pas une condition"}))[:code]).to eq 404 }
     end
 
@@ -52,13 +53,13 @@ describe DbAccessor::Reader do
   describe ".select_by_id" do
 
     context "when it reads on a model with an id" do
-      it {expect((DbAccessor::Reader.select_by_id({model_name: "User",identifiers: [5]}))[:code]).to eq 200 } 
+      it {expect((DbAccessor::Reader.select_by_id({model_name: "User",identifiers: [5]}))[:code]).to eq 200 }
 
-      it {expect((DbAccessor::Reader.select_by_id({model_name: "User",identifiers: [5]}))[:message]).to_not eq nil } 
+      it {expect((DbAccessor::Reader.select_by_id({model_name: "User",identifiers: [5]}))[:message]).to_not eq nil }
 	end
- 
+
     context "when one of the ids is incorrect" do
-      it {expect((DbAccessor::Reader.select_by_id({model_name: "User",identifiers: [1,2,'c']}))[:code]).to eq 404 } 
+      it {expect((DbAccessor::Reader.select_by_id({model_name: "User",identifiers: [1,2,'c']}))[:code]).to eq 404 }
 	end
 
     context "when one of the parameter is nil" do
@@ -83,5 +84,5 @@ describe DbAccessor::Reader do
 
   end
 
-  
+
 end

data/spec/spec_helper.rb

@@ -1,2 +1,3 @@
 require_relative 'fixtures/env'
 require 'uuid'
+require 'json'

data/spec/writer_spec.rb

@@ -8,9 +8,9 @@ describe DbAccessor::Writer do
 
   let(:user) { {model_name: 'User',content: {login: 'diakhoumpa'+nb.to_s,password: 'passeraa',firstname: 'Ndeye Fatou', lastname: 'Dieng',email: 'diakhouumpa'+nb.to_s+'@gmail.com',gender: 'M'}} }
 
-  let(:app) { {model_name: 'Application',content: {name: 'desert'+nb.to_s,api_key: api_key,url: 'http://www.desert'+nb.to_s+'.com',user_id: 2}} }   
-  
-  let(:engine) { {model_name: 'Engine',content: {name: 'engine'+nb.to_s,application_id: 2}} }   
+  let(:app) { {model_name: 'Application',content: {name: 'desert'+nb.to_s,api_key: api_key,url: 'http://www.desert'+nb.to_s+'.com',user_id: 2}} }
+
+  let(:engine) { {model_name: 'Engine',content: {engine_conf: {name: 'engine'+nb.to_s,action: ['LIKE','SHARE'],score: [2,5],algorithm: 'Person',type: 'UserBased', neighborhood: 5 }.to_json ,application_id: 2}} }
 
   describe".write_object" do
 
@@ -31,35 +31,35 @@ describe DbAccessor::Writer do
     end
 
     context "when the model_name contains numbers" do
-     it {expect((DbAccessor::Writer.write_object({model_name: 'DGH67889',content: user[:content]}))[:code]).to eq 400 } 
+     it {expect((DbAccessor::Writer.write_object({model_name: 'DGH67889',content: user[:content]}))[:code]).to eq 400 }
     end
-        
+
     context "when passed parameter's keys are incorrect" do
-     it {expect((DbAccessor::Writer.write_object({model: 'DGH67889',con: user[:content]}))[:code]).to eq 400 } 
+     it {expect((DbAccessor::Writer.write_object({model: 'DGH67889',con: user[:content]}))[:code]).to eq 400 }
     end
 
     context "when the parameter is not a hash" do
-      it { expect((DbAccessor::Writer.write_object("coucou"))[:code]).to eq 400 } 
+      it { expect((DbAccessor::Writer.write_object("coucou"))[:code]).to eq 400 }
     end
 
     context "when the parameter's keys are not correct" do
-      it { expect((DbAccessor::Writer.write_object({t: "coucou"}))[:code]).to eq 400 } 
+      it { expect((DbAccessor::Writer.write_object({t: "coucou"}))[:code]).to eq 400 }
     end
-    
+
     context "when required parameters are not given" do
-     user =  {model_name: 'User',content: {firstname: 'ablaye', lastname: 'Dieng',gender: 'M'} }  
+     user =  {model_name: 'User',content: {firstname: 'ablaye', lastname: 'Dieng',gender: 'M'} }
      it { expect((DbAccessor::Writer.write_object(user))[:code]).to eq 400 }
     end
-    
+
     context "when required parameters are not correct" do
-     user = {model_name: 'User',content: {login: nb.to_s,password: 'passer',firstname: 'Ndeye Fatou', lastname: 'Dieng',email: 'fatou',gender: 'M'}}  
+     user = {model_name: 'User',content: {login: nb.to_s,password: 'passer',firstname: 'Ndeye Fatou', lastname: 'Dieng',email: 'fatou',gender: 'M'}}
      it { expect((DbAccessor::Writer.write_object(user))[:code]).to eq 400 }
     end
 
     context "when the content doesn't correspond to the model_name" do
      it { expect((DbAccessor::Writer.write_object( {model_name: 'User',content: {name: 'Wiki',api_key: api_key,url: 'http://www.wiki.com',user_id: 2}} ))[:code]).to eq 400 }
     end
-    
+
     context "when the content is incorrect" do
      it { expect((DbAccessor::Writer.write_object( {model_name: 'Utilisateur',content: "coucou"} ))[:code]).to eq 400 }
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dbAccessor
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - fabira
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-23 00:00:00.000000000 Z
+date: 2014-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler