dbAccessor 0.0.7

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

@@ -0,0 +1,21 @@
+
+class CreateApplications < ActiveRecord::Migration
+  def self.up
+    create_table :applications do |a|
+      a.string  :name
+      a.uuid    :api_key
+      a.string  :url
+      a.boolean :deleted, :default => false
+      a.integer :user_id
+      a.timestamps
+    end
+    add_index :applications, :user_id
+  end 
+  
+  def self.down
+    drop_table :applications
+  end
+end
+
+CreateApplications.up
+

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

@@ -0,0 +1,4 @@
+ActiveRecord::Migration.create_table :items do |t|
+  t.string :name
+  t.timestamps
+end

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

@@ -0,0 +1,22 @@
+require 'active_record'
+
+class CreateUsers < ActiveRecord::Migration
+  def self.up
+    create_table :users do |u|
+      u.string  :login
+      u.string  :password
+      u.string  :firstname
+      u.string  :lastname
+      u.string  :gender
+      u.string  :email
+      u.boolean :deleted, :default => false
+      u.timestamps
+    end
+  end 
+  
+  def self.down
+    drop_table :users
+  end
+end
+
+CreateUsers.up

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

@@ -0,0 +1,4 @@
+ActiveRecord::Migration.create_table :utilisateurs do |t|
+  t.string :name
+  t.timestamps
+end 

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

@@ -0,0 +1,8 @@
+require 'active_record'
+require_relative 'utilisateur'
+require_relative 'item'
+
+class Action < ActiveRecord::Base
+  belongs_to :utilisateur
+  belongs_to :item
+end

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

@@ -0,0 +1,10 @@
+
+require 'active_record'
+require_relative 'user'
+
+class Application < ActiveRecord::Base
+  
+  validates_presence_of   :name, :api_key, :url
+  validates_uniqueness_of :api_key, :url
+  belongs_to              :user
+end

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

@@ -0,0 +1,8 @@
+require 'active_record'
+require_relative 'utilisateur'
+require_relative 'action'
+
+class Item < ActiveRecord::Base
+  has_many :actions
+  has_many :users, :through => :actions
+end

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

@@ -0,0 +1,9 @@
+require 'active_record'
+require_relative 'application'
+
+class User < ActiveRecord::Base
+  
+  validates_presence_of   :login, :password, :email
+  validates_uniqueness_of :login, :email
+  has_many                :applications
+end

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

@@ -0,0 +1,8 @@
+require 'active_record'
+require_relative 'item'
+require_relative 'action'
+
+class Utilisateur < ActiveRecord::Base
+  has_many :actions
+  has_many :items, :through => :actions
+end

data/spec/feed/resources/do_migration.rb

@@ -0,0 +1,5 @@
+require_relative '../../../lib/dbAccessor/dbConnector.rb'
+require_relative '../dbTest/migration/create_table_users'
+require_relative '../dbTest/migration/create_table_applications'
+
+

data/spec/feed/resources/environment.rb

@@ -0,0 +1,3 @@
+require_relative '../../../lib/dbAccessor/dbConnector' 
+require_relative '../dbTest/model/application'
+require_relative '../dbTest/model/user'

data/spec/feed/resources/populate.rb

@@ -0,0 +1,28 @@
+require_relative 'environment'
+require 'uuid'
+
+class Populate
+  #generating 10 items
+#  p "Creating 5 users:"
+ i = 1
+ 5.times do
+    p User.create( login: 'fabira'+i.to_s,password: 'passer', firstname: 'binette'+i.to_s, lastname: 'dieng',gender: 'F',email: 'fabira'+i.to_s+'gmail.com',deleted: false )
+    i = i + 1
+  end
+
+ uuid = UUID.new
+ 
+    #linking users and items by actions
+  p "Creating actions on items by users"
+  p Application.create( name: 'Facebook',api_key: uuid.generate,url: 'http://www.facebook.com',deleted: false,user_id: User.first.id )
+
+  p Application.create( name: 'Twitter',api_key: uuid.generate,url: 'http://www.twitter.com',deleted: false,user_id: User.find(2).id )
+
+  p Application.create( name: 'Axolot',api_key: uuid.generate,url: 'http://www.axolot.com',deleted: false,user_id: User.last.id )
+
+  p Application.create( name: 'Gmail',api_key: uuid.generate,url: 'http://www.gmail.com',deleted: false,user_id: User.find(4).id )
+  
+
+  p "Done! ;)"
+  
+end

data/spec/fixtures/env.rb

@@ -0,0 +1 @@
+require 'dbAccessor'

data/spec/reader_spec.rb

@@ -0,0 +1,85 @@
+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		
+    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
+
+    context "when the last model's item is found" do
+     it {expect((DbAccessor::Reader.simple_select({model_name: "Application",action_on: "last"}))[:code]).to eq 200 }
+    end
+
+    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
+  end
+
+  describe ".condition_select" do
+
+    context "when it reads one or many items on table with a condition" do
+      it {expect((DbAccessor::Reader.condition_select({model_name: "User" , condition: {login: "fabira3"}}))[:code]).to eq 200 }
+	end
+
+    context "when the condition is not satisfied" do
+      it {expect((DbAccessor::Reader.condition_select({model_name: "Application" , condition: {name: "fab"}}))[:code]).to eq 404 }
+	end
+
+    context "when one or many parameters are empty or nil" do
+      it {expect((DbAccessor::Reader.condition_select({model_name: "", condition: nil }))[:code]).to eq 404 }
+    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: "pas une condition"}))[:code]).to eq 404 }
+    end
+
+    context "when passed parameter's keys are not correct" do
+        it {expect((DbAccessor::Reader.simple_select({model: "User",cond: nil}))[:code]).to eq 404 }
+    end
+  end
+
+  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: [7,8,9]}))[:code]).to eq 200 } 
+	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 } 
+	end
+
+    context "when one of the parameter is nil" do
+        it {expect((DbAccessor::Reader.select_by_id({model_name: "",identifiers: [1,2,3]}))[:code]).to eq 404 }
+    end
+
+  end
+
+  describe ".linked_models_select" do
+
+    context "when it reads models on model with a condition" do
+      it {expect((DbAccessor::Reader.linked_models_select({model_name: "User", condition: { id: 2}, models: "applications"}))[:code]).to eq 200 }
+	end
+
+    context "when a parameter is empty or empty" do
+        it {expect((DbAccessor::Reader.linked_models_select({model_name: "", condition: nil, models: nil }))[:code]).to eq 404 }
+    end
+
+    context "when models are incorrect" do
+        it {expect((DbAccessor::Reader.linked_models_select({model_name: "", condition: nil, models: "pas de model" }))[:code]).to eq 404 }
+    end
+
+  end
+
+  
+end

data/spec/spec_helper.rb

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

data/spec/updater_spec.rb

@@ -0,0 +1,96 @@
+require_relative 'spec_helper'
+
+describe DbAccessor::Updater do
+ 
+  describe ".update_by_id" do
+	context "updates one or many users by id" do
+	  param = {model_name: "User",attributes: { 3 => {login: "fabira"}} }
+	  it {expect((DbAccessor::Updater.update_by_id(param))[:code]).to eq 200 }
+	end
+
+	context "updates one or many applications by id" do
+	  param = {model_name: "Application",attributes: { 3 => { name: "apache"},2 => {name: "site du zero"}} }
+	  it {expect((DbAccessor::Updater.update_by_id(param))[:code]).to eq 200 }
+	end
+
+    context "when attributes format is not correct" do
+	  param = {model_name: "Application",attributes: { 'c' => { name: "apache"},2 => {name: "site du zero"}} }
+	  it {expect((DbAccessor::Updater.update_by_id(param))[:code]).to eq 400 }
+
+	  param[:attributes] = { 3 => { na: "apache"},2 => {name: "site du zero"}} 
+	  it {expect((DbAccessor::Updater.update_by_id(param))[:code]).to eq 400 }
+
+	  param[:attributes] = { 3 => { name: 1},2 => {name: "site du zero"}}
+	  it {expect((DbAccessor::Updater.update_by_id(param))[:code]).to eq 400 }
+
+	  param[:attributes] = { 3 => nil,2 => {name: "site du zero"}}
+	  it {expect((DbAccessor::Updater.update_by_id(param))[:code]).to eq 400 }
+
+	  param[:attributes] = { 3 => " ",2 => {name: "site du zero"}}
+	  it {expect((DbAccessor::Updater.update_by_id(param))[:code]).to eq 400 }
+
+	  param[:attributes] = { 3 => {},2 => {name: "site du zero"}}
+	  it {expect((DbAccessor::Updater.update_by_id(param))[:code]).to eq 400 }
+
+	  param[:attributes] = { 3 => {name: nil},2 => {name: "site du zero"}}
+	  it {expect((DbAccessor::Updater.update_by_id(param))[:code]).to eq 400 }
+
+	  param[:attributes] = { 3 => {na: 'to'},2 => {name: "site du zero"}}
+	  it {expect((DbAccessor::Updater.update_by_id(param))[:code]).to eq 400 }
+	end
+
+	context "when the object is not found" do
+	  param = {model_name: "User",attributes: { 100 => { login: "fabi"}} } 
+      it {expect((DbAccessor::Updater.update_by_id(param))[:code]).to eq 400 }
+    end
+
+    context "when the passed parameter is nil" do 
+      it {expect((DbAccessor::Updater.update_by_id(nil))[:code]).to eq 400 }
+    end
+
+    context "when attributes to update are empty" do 
+      it {expect((DbAccessor::Updater.update_by_id(model_name: "User",attributes: {}))[:code]).to eq 400 }
+    end
+
+    context "when the model name is incorrect" do 
+      it {expect((DbAccessor::Updater.update_by_id(model_name: "Us",attributes: {}))[:code]).to eq 400 }
+    end
+
+    context "when the attributes are not correct" do 
+      it {expect((DbAccessor::Updater.update_by_id(model_name: "Application",attributes: "coucou"))[:code]).to eq 400 }
+    end
+
+  end
+
+  describe ".update_all_objects" do
+	parameter={model_name:  "User", attributes: {login: 'fabira3',password: 'passe'}}
+    context "when it updates all model objects" do
+      it {expect((DbAccessor::Updater.update_all_objects(parameter))[:code]).to eq 200 }
+	end
+
+    context "when all model objects that satisfy the condition are updated" do
+	  condition="id == 3"
+	  it {expect((DbAccessor::Updater.update_all_objects(parameter,condition))[:code]).to eq 200 }
+	end
+
+    context "when model's attributes are not correct" do
+      param={model_name:  "User", attributes: {login: 'fabira',password: 3}}
+      it {expect((DbAccessor::Updater.update_all_objects(param))[:code]).to eq 400 }
+    end
+
+    context "when one of the model's attributes is nil" do
+      param={model_name:  "User", attributes: {login: 'fabira',password: nil}}
+      it {expect((DbAccessor::Updater.update_all_objects(param))[:code]).to eq 400 }
+    end
+
+    context "when attributes'keys are not correct" do
+      param={model_name:  "User", attributes: {lon: 'fabira',pasord: 'pass'}}
+      it {expect((DbAccessor::Updater.update_all_objects(param))[:code]).to eq 400 }
+    end
+
+    context "returns false when attributes keys don't correspond to the model" do
+      param={model_name:  "Application", attributes: {login: 'fabira3',password: 'passera'}}
+      it {expect((DbAccessor::Updater.update_all_objects(param))[:code]).to eq 400 }
+    end
+  end
+end

data/spec/writer_spec.rb

@@ -0,0 +1,72 @@
+require_relative 'spec_helper'
+
+
+describe DbAccessor::Writer do
+
+  nb      = rand(1000)
+  api_key = UUID.new.generate
+
+  let(:user) { {model_name: 'User',content: {login: 'ab'+nb.to_s,password: 'passer',firstname: 'Ndeye Fatou', lastname: 'Dieng',email: 'ab'+nb.to_s+'@gmail.com',gender: 'M'}} }
+
+  let(:app) { {model_name: 'Application',content: {name: 'Wiki'+nb.to_s,api_key: api_key,url: 'http://www.wiki'+nb.to_s+'.com',user_id: 2}} }   
+  
+
+  describe".write_object" do
+
+    context "when a user is saved in database" do
+      it {expect((DbAccessor::Writer.write_object(user))[:code]).to eq 201}
+    end
+
+    context "when an application is saved in database" do
+      it {expect((DbAccessor::Writer.write_object(app))[:code]).to eq 201}
+    end
+
+    context "when the object's parameters are empty" do
+     it {expect((DbAccessor::Writer.write_object({model_name: '',content: user[:content]}))[:code]).to eq 400 }
+    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 } 
+    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 } 
+    end
+
+    context "when the parameter is not a hash" do
+      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 } 
+    end
+    
+    context "when required parameters are not given" do
+     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'}}  
+     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
+
+    context "when the model_name is missing" do
+     it { expect((DbAccessor::Writer.write_object( {model_name: '',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 not correct" do
+     it { expect((DbAccessor::Writer.write_object( {model_name: 'Application',content: {login: nb.to_s,password: 'passer',firstname: 'Ndeye Fatou', lastname: 'Dieng',email: 'fatou',gender: 'M'}} ))[:code]).to eq 400 }
+    end
+
+  end
+
+end