guara 0.0.1.rc

data/spec/models/system_task_resolution_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe SystemTaskResolution do
+
+  let(:system_task_status) { SystemTaskResolution.RESOLVED }
+  
+  subject { system_task_status }
+  
+  it { should respond_to(:name) }
+
+  it { SystemTaskResolution.should respond_to(:RESOLVED) }
+  it { SystemTaskResolution.should respond_to(:CANCELED) }
+  it { SystemTaskResolution.should respond_to(:BLOCKED) }
+    
+  it { should be_valid }
+  
+end

data/spec/models/system_task_status_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe SystemTaskStatus do
+  
+  let(:system_task_status) { SystemTaskStatus.OPENED }
+  
+  subject { system_task_status }
+  
+  it { should respond_to(:name) }
+
+  it { SystemTaskStatus.should respond_to(:OPENED) }
+  it { SystemTaskStatus.should respond_to(:IN_PROGRESS) }
+  it { SystemTaskStatus.should respond_to(:PAUSED) }
+  it { SystemTaskStatus.should respond_to(:CLOSED) }
+    
+  it { should be_valid }  
+end

data/spec/models/task_feedback_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe TaskFeedback do
+  
+  let(:task) { Factory(:task, status: SystemTaskStatus.CLOSED, resolution: SystemTaskResolution.RESOLVED) }
+  let(:user) { Factory(:user) }
+  
+  before do
+#    able(user, :read, :task)
+#    able(user, :update, :task)
+#    able(user, :read, :task_feedback)
+#    able(user, :update, :task_feedback)
+    @task_feedback = TaskFeedback.create(task: task,
+                                       date: 1.day.ago,
+                                       notes: Faker::Lorem.sentence(7),
+                                       user: user,
+                                       status: task.status,
+                                       resolution: SystemTaskResolution.RESOLVED);
+  end
+  
+  subject { @task_feedback }
+  
+  it { should respond_to(:task_id) }
+  it { should respond_to(:date) }
+  it { should respond_to(:notes) }
+  it { should respond_to(:user_id) }
+  it { should respond_to(:status_id) }
+  it { should respond_to(:resolution_id) }
+  
+  it { should be_valid }
+  
+  it "feedback should included in task" do
+    task.feedbacks.should include(@task_feedback)
+  end
+  
+  describe "not filled required fields" do
+    before do
+      @task_feedback.notes = ''
+      @task_feedback.resolution = nil
+    end
+    
+    it { should be_invalid }
+  end
+  
+  
+end

data/spec/models/task_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper'
+
+describe Task do
+  
+  
+  before(:all) { clear_test_dummy }
+  
+  let(:customer_pj) { FactoryGirl.create(:customer_pj) }
+  let(:contact) { FactoryGirl.create(:contact, customer: customer_pj.customer) }
+  let(:user) { user = FactoryGirl.create(:user) }
+  
+  before do
+    
+    @task = Task.create(name: "task "+Faker::Lorem.sentence(4)[0..52],
+                       interested: customer_pj,
+                       contact: contact,
+                       user: user,
+                       assigned: user,
+                       notes: Faker::Lorem.sentence(60)[0..139],
+                       description: Faker::Lorem.sentence(140)[0..999],
+                       due_time: Date.today + 10.days,
+                       finish_time: nil,
+                       status: SystemTaskStatus.OPENED,
+                       resolution: nil,
+                       type: FactoryGirl.create(:task_type)
+                       )
+    
+  end
+  
+  subject { @task }
+  
+  it { should respond_to(:interested) }
+  it { should respond_to(:name) }
+  it { should respond_to(:contact) }
+  it { should respond_to(:user) }
+  it { should respond_to(:assigned) }
+  it { should respond_to(:notes) }
+  it { should respond_to(:description) }  
+  it { should respond_to(:due_time) }
+  it { should respond_to(:finish_time) }
+  it { should respond_to(:status) }
+  it { should respond_to(:resolution) }
+  it { should respond_to(:type) }
+  it { should respond_to(:assigned) }
+  it { should respond_to(:feedbacks) }
+  
+  it { should respond_to(:done?) }
+  it { should respond_to(:done) }
+  it { should respond_to(:due_critical_level) }
+  
+  it { should be_valid }
+  
+  describe "specials accessible fields" do
+    it "attr user must be accessible" do
+      expect do
+        @task.user = nil
+      end.to_not raise_error(ActiveModel::MassAssignmentSecurity::Error)  
+    end
+    
+    it "attr status must be accessible" do
+      expect do
+        @task.status = nil
+      end.to_not raise_error(ActiveModel::MassAssignmentSecurity::Error)  
+    end
+  end  
+    
+  describe "required fields must be checked" do
+    before do
+       @task.status = SystemTaskStatus.CLOSED
+       @task.resolution = SystemTaskResolution.RESOLVED
+    end
+    
+    describe "and invalid status equals nil" do
+      before { @task.status = nil }
+      it { should be_invalid }
+    end
+    
+    describe "and invalid user equals nil" do
+      before { @task.user = nil }
+      it { should be_invalid }
+    end
+    
+    describe "invalid status for RESOLVED and OPENED" do
+      before { @task.status = SystemTaskStatus.OPENED }
+      it { should be_invalid }
+    end
+    
+    describe "invalid notes is empty" do
+      before { @task.notes = '' }
+      it { should be_invalid }
+    end
+    
+    describe "invalid name" do
+      before { @task.name = 'a' }
+      it { should be_invalid }
+    end
+    
+    describe "empty name" do
+      before { @task.name = '' }
+      it { should be_invalid }
+    end
+    
+    describe "empty status is invalid" do
+      before do
+        @task.status = nil
+      end
+
+      it { should be_invalid }
+    end
+  end
+  
+  describe "is done and valid" do
+    before do
+      @task.resolution = SystemTaskResolution.RESOLVED
+      @task.status = SystemTaskStatus.CLOSED
+    end
+    
+    it { should be_valid }
+  end
+  
+  
+  describe "STATUS is OPENED and resolution is not valid" do
+    before { @task.status = SystemTaskStatus.OPENED }
+    
+    describe "try RESOLVED resolution" do
+      before { @task.resolution = SystemTaskResolution.RESOLVED }
+      it { should be_invalid }
+    end
+  
+    describe "try CANCELED resolution" do
+      before { @task.resolution = SystemTaskResolution.CANCELED }
+      it { should be_invalid }
+    end  
+  
+  
+    describe "try BLOCKED resolution" do
+      before { @task.resolution = SystemTaskResolution.BLOCKED }
+      it { should be_invalid }
+    end
+  end
+  
+  describe "associated with a CUSTOMER destroyed, must also be destroyed" do
+    it { expect { customer_pj.customer.destroy_fully }.to change{ Task.count }.by(-1*customer_pj.customer.tasks.count) }
+  end
+  
+  it "STATUS is CLOSE" do
+    @task.status = SystemTaskStatus.CLOSED
+    should be_done
+  end
+  
+  describe "due time ending" do
+    
+    it "overdue" do
+      @task.due_time = 2.days.ago
+      @task.due_critical_level.should be(3)
+    end
+    
+    it "4 days remain its critical, level is 2" do
+      @task.due_time = Time.now + 3.days
+      @task.due_critical_level.should be(2)
+    end
+    
+    it "Long time remaining, critical level 1" do
+      @task.due_time = Time.now + 200.days
+      @task.due_critical_level.should be(1)
+    end
+    
+    
+    it "and tasks is done, critical level is 0" do
+      @task.due_time = 2.days.ago
+      @task.done
+      @task.due_critical_level.should be(0)
+    end
+  end
+
+end

data/spec/models/task_type_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe TaskType do
+
+  let(:type) { TaskType.new(name: Faker::Name.first_name) }
+  
+  subject { type }
+  
+  it { should respond_to(:name) }
+  it { should respond_to(:company_business)}
+  it { should be_valid }
+
+  it { TaskType.should respond_to(:for_business)}
+
+  
+  describe "Company Business" do
+    before do
+      type.company_business = Factory(:company_business)
+      @another = Factory(:company_business)
+      type.save!
+    end
+    
+    it { TaskType.for_business(type.company_business).should include(type) }
+    it { TaskType.for_business(@another).should_not include(type) }
+  end
+  
+end

data/spec/models/tests/ajax_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Tests::Ajax do
+  pending "add some examples to (or delete) #{__FILE__}"
+end

data/spec/models/user_ability_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe UserAbility do
+
+  let!(:user) { FactoryGirl.create(:user) }
+  
+  before do
+    @user_ability = UserAbility.create!(:skilled => user, 
+                                    :ability => SystemAbility.READ,
+                                    :module => SystemModule.CUSTOMER)
+                                    
+    user.reload
+  end
+
+  subject { @user_ability }
+
+  it { should respond_to :skilled }
+  it { should respond_to :ability }  
+  it { should respond_to :module }
+  it { should respond_to :garant }
+  it { UserAbility.should respond_to :for }
+  
+  it { should be_valid }
+  
+  describe "garant ability to user read cutomers " do
+    it { user.abilities.should include @user_ability }
+  end
+  
+  describe "list user abilities for module" do
+    it "customer" do
+      UserAbility.for(user, SystemModule.CUSTOMER).should include SystemAbility.READ
+    end
+  end
+  
+end

data/spec/models/user_group_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe UserGroup do
+
+  before do
+    @users_group = UserGroup.new( name: "Operators" )
+  end
+  
+  subject { @users_group }
+  
+  it { should respond_to :name }
+  it { should respond_to :abilities }
+  it { should be_valid }
+  
+  describe "Have abilities" do
+    before do      
+      @user_abillity_1 = @users_group.abilities.build(:ability => SystemAbility.READ,   :module => SystemModule.CUSTOMER)
+      @user_abillity_2 = @users_group.abilities.build(:ability => SystemAbility.CREATE, :module => SystemModule.CUSTOMER)
+    end
+    it { should be_valid }
+    
+    its (:abilities) { should == [@user_abillity_1, @user_abillity_2] }
+    
+  end
+
+end

data/spec/models/user_spec.rb

@@ -0,0 +1,274 @@
+# == Schema Information
+#
+# Table name: users
+#
+#  id         :integer         not null, primary key
+#  name       :string(25)
+#  email      :string(100)
+#  created_at :datetime        not null
+#  updated_at :datetime        not null
+#
+
+require 'spec_helper'
+
+include UsersHelper
+
+describe User do
+
+  before(:all) { clear_test_dummy }
+
+  before do
+    @user = User.new(name: "Example User", email: "user@example.com", 
+                     password: "foobar", password_confirmation: "foobar")
+  end
+
+  subject { @user }
+  
+  let(:found_user) { User.find_by_email(@user.email)?:found_user:@user }
+
+  it { should respond_to(:name) }
+  it { should respond_to(:email) }
+  it { should respond_to(:password_digest) }
+  it { should respond_to(:password) }
+  it { should respond_to(:password_confirmation) }
+  it { should respond_to(:remember_token) }
+  
+  it { should respond_to(:microposts) }
+  it { should respond_to(:feed) }
+  
+  #colaboration
+  it { should respond_to(:relationships) }
+  it { should respond_to(:followed_users) }  
+  it { should respond_to(:following?) }
+  it { should respond_to(:follow!) }
+  it { should respond_to(:followers) }
+  
+  #groups
+  it { should respond_to :groups }
+  it { should respond_to :primary_group }
+  it { should respond_to :secundary_groups }
+    
+  it { should respond_to(:admin) }
+  
+  it { should respond_to(:primary_company_business) }
+
+  it { should be_valid }
+  it { should_not be_admin }
+  
+  it { respond_to :able? }
+
+  describe "when name is not present" do
+    before { @user.name = " " }
+    it { should_not be_valid }
+  end
+  
+  describe "when email format is invalid" do
+    it "should be invalid" do
+      addresses = %w[user@foo,com user_at_foo.org example.user@foo.
+                     foo@bar_baz.com foo@bar+baz.com]
+      addresses.each do |invalid_address|
+        @user.email = invalid_address
+        @user.should_not be_valid
+      end      
+    end
+  end 
+
+  describe "when email format is valid" do
+    it "should be valid" do
+      addresses = %w[user@foo.COM A_US-ER@f.b.org frst.lst@foo.jp a+b@baz.cn]
+      addresses.each do |valid_address|
+        @user.email = valid_address
+        @user.should be_valid
+      end      
+    end
+  end
+  
+  describe "when email address is already taken" do
+      before do
+        user_with_same_email = @user.dup
+        user_with_same_email.email = @user.email.upcase
+        user_with_same_email.save
+      end
+
+      it { should_not be_valid }
+  end
+  
+  #PASSWORDS TESTS <================================================
+  
+  describe "when password is not present" do
+    before { @user.password = @user.password_confirmation = " " }
+    it { should_not be_valid }
+  end
+
+  describe "when password doesn't match confirmation" do
+    before { @user.password_confirmation = "mismatch" }
+    it { should_not be_valid }
+  end
+
+  describe "when password confirmation is nil" do
+    before { @user.password_confirmation = nil }
+    it { should_not be_valid }
+  end
+
+  describe "with a password that's too short" do
+    before { @user.password = @user.password_confirmation = "a" * 5 }
+    it { should be_invalid }
+  end
+
+  describe "email address with mixed case" do
+    let(:mixed_case_email) { "Foo@ExAMPle.CoM" }
+
+    it "should be saved as all lower-case" do
+      @user.email = mixed_case_email
+      @user.save
+      @user.reload.email.should == mixed_case_email.downcase
+    end
+  end
+
+  #AUTHENTICATION <================================================
+=begin  
+  describe "return value of authenticate method" do
+    before { @user.save }
+    let(:found_user) { User.find_by_email(@user.email) }
+
+    describe "with valid password" do
+      it { should == found_user.authenticate(@user.password) }
+    end
+
+    describe "with invalid password" do
+      let(:user_for_invalid_password) { found_user.authenticate("invalid") }
+
+      it { should_not == user_for_invalid_password }
+      specify { user_for_invalid_password.should be_false }
+    end
+  end
+=end
+
+  #REMEMBER <================================================
+  
+  describe "remember token" do
+    before { @user.save }
+    its(:remember_token) { should_not be_blank }
+  end
+  
+  
+  #ADMIN <================================================
+  
+    describe "with admin attribute set to 'true'" do
+      before { @user.toggle!(:admin) }
+      it { should be_admin }
+      
+      it "attr admin must be accessible" do
+        expect do
+          @user.toggle!(:admin)
+        end.to_not raise_error(ActiveModel::MassAssignmentSecurity::Error)  
+      end
+      
+    end
+    
+  #MICROPOSTS <==============================================
+  
+  describe "micropost associations" do
+
+    before { @user.save }
+    let!(:older_micropost) do 
+      FactoryGirl.create(:micropost, user: @user, created_at: 1.day.ago)
+    end
+    let!(:newer_micropost) do
+      FactoryGirl.create(:micropost, user: @user, created_at: 1.hour.ago)
+    end
+
+    it "should have the right microposts in the right order" do
+      @user.microposts.should == [newer_micropost, older_micropost]
+    end
+    
+    it "should destroy associated microposts" do
+      microposts = @user.microposts
+      @user.destroy_fully
+      microposts.each do |micropost|
+        Micropost.find_by_id(micropost.id).should be_nil
+      end
+    end
+    
+    describe "status" do
+      let(:unfollowed_post) do
+        FactoryGirl.create(:micropost, user: FactoryGirl.create(:user))
+      end
+
+      its(:feed) { should include(newer_micropost) }
+      its(:feed) { should include(older_micropost) }
+      its(:feed) { should_not include(unfollowed_post) }
+    end
+  end
+  
+  #FOLLOWING<===================================================
+  
+  describe "following" do
+    let(:other_user) { FactoryGirl.create(:user) }    
+    before do
+      @user.save
+      @user.follow!(other_user)
+    end
+
+    it { should be_following(other_user) }
+    its(:followed_users) { should include(other_user) }
+    
+    describe "and unfollowing" do
+      before { @user.unfollow!(other_user) }
+
+      it { should_not be_following(other_user) }
+      its(:followed_users) { should_not include(other_user) }
+    end
+    
+    it { should be_following(other_user) }
+    its(:followed_users) { should include(other_user) }
+
+    describe "followed user" do
+      subject { other_user }
+      its(:followers) { should include(@user) }
+    end
+    
+  end
+
+
+  #User and Groups<=============================================
+  
+  describe "have a primary group or not " do
+    it(:primary_group) { @user.primary_group = UserGroup.first }
+    it { should be_valid }
+  end
+  
+  describe "have many groups" do
+    let(:group_primary) { UserGroup.first }
+    let(:group_secs) { [FactoryGirl.create(:user_group), FactoryGirl.create(:user_group)] }
+    before do
+      @user.primary_group = group_primary
+      @user.secundary_groups = group_secs
+      @user.save!
+    end
+    
+    its (:groups) { should include(group_secs[0]) }
+    its (:groups) { should include(group_secs[1]) }
+    
+  end
+  
+
+  
+  describe "user able?" do
+    before do
+      able(@user, :create, :customer)
+      able(@user, :read, :user)
+    end
+    
+    it { @user.able?(SystemModule.CUSTOMER, SystemAbility.CREATE).should be_true }
+    it { @user.able?(SystemModule.USER, SystemAbility.READ).should be_true }
+    it { @user.able?(SystemModule.USER, SystemAbility.CREATE).should_not be_true }
+  end
+  
+  
+  describe "tasks" do
+    let(:task)  { FactoryGirl.create(:task, user: @user) }
+    it { @user.tasks.should include(task) }
+  end
+  
+end