invitational 1.3.2 → 1.3.3

data/spec/invitational/models/ability_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+require 'cancan/matchers'
+require 'invitational/services/service_helper'
+
+describe Ability do
+
+  Given(:user1) { setup_user "test1@d-i.co" }
+  Given(:user2) { setup_user "test2@d-i.co" }
+  Given(:user3) { setup_user "test3@d-i.co" }
+  Given(:user4) { setup_user "test4@d-i.co" }
+  Given(:user5) { setup_user "test5@d-i.co" }
+
+  Given(:entity1) { setup_entity "Test entity 1"}
+  Given(:entity2) { setup_entity "Test entity 2"}
+  Given(:child1) {setup_child "Child 1", entity2}
+  Given(:grandparent) {setup_grandparent "A Grandparent", entity2}
+
+  Given(:other_entity) { setup_other_entity "Test other entity"}
+  Given(:system_thing) { setup_system_thing "A System Object" }
+
+  Given {invite_user user1, entity1, :user}
+  Given {invite_user user2, entity2, :admin}
+  Given {invite_user user5, grandparent, :admin}
+
+  Given {invite_uber_admin user3}
+  Given {invite_system_role user4, :employer}
+
+  context "User" do
+    Given (:i) { Ability.new(user1) }
+    When (:role) {:user}
+
+    Then { i.should be_able_to(:read, entity1) }
+    And { i.should_not be_able_to(:manage, entity1) }
+    And { i.should_not be_able_to(:read, entity2) }
+  end
+
+  context "Admin" do
+    Given (:i) { Ability.new(user2) }
+    When (:role) {:admin}
+
+    Then { i.should be_able_to(:read, entity2) }
+    And { i.should be_able_to(:manage, entity2) }
+    And { i.should_not be_able_to(:read, entity1) }
+  end
+
+  context "System - Employer" do
+    Given (:i) { Ability.new(user4) }
+    When (:role) {:employer}
+
+    Then { i.should be_able_to(:manage, system_thing) }
+  end
+
+  context "Uber Admin" do
+    Given (:i) { Ability.new(user3) }
+    When (:role) {:uberadmin}
+
+    Then { i.should be_able_to(:manage, entity1) }
+    And { i.should be_able_to(:manage, entity2) }
+    And {i.should be_able_to(:manage, child1)}
+    And { i.should be_able_to(:manage, other_entity) }
+    And { i.should be_able_to(:manage, system_thing) }
+  end
+
+  context "Uber Admin only permissions" do
+    Given (:i) { Ability.new(user3) }
+    When (:role) {:uberadmin}
+
+    Then { i.should be_able_to(:manage, other_entity) }
+  end
+
+  context "Cascading Permissions" do
+    context "One level" do
+      Given (:i) { Ability.new(user2) }
+      When (:role) {:admin}
+
+      Then {i.should be_able_to(:manage, child1)}
+    end
+
+    context "Two levels" do
+      Given (:i) { Ability.new(user5) }
+      When (:role) {:admin}
+
+      Then {i.should be_able_to(:manage, child1)}
+    end
+  end
+
+  context "Access to everybody" do
+    Given (:i) { Ability.new(user1) }
+    When (:role) {:admin}
+
+    Then {i.should be_able_to(:read, child1) }
+  end
+
+end

data/spec/invitational/models/entity_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'invitational/services/service_helper'
+
+describe Entity do
+  Given {no_invitations_exist}
+
+  Given(:user) { setup_user "test1@d-i.co" }
+  Given(:entity) { setup_entity "Test entity 1"}
+
+  context "relationships" do
+    When {invite_user user, entity, :admin}
+
+    Then {entity.admins.should include(user)}
+  end
+
+  context "inviting" do
+    context "Users can be invited with a defined role" do
+      When(:result) {entity.invite user, :admin}
+
+      Then  {result.should_not be_nil}
+      And   {result.invitable.should == entity}
+      And   {result.user.should == user }
+      And   {result.role.should == :admin}
+      And   {result.claimed?.should be_true}
+    end
+
+    context "Users cannot be invited again if they are already invited" do
+      Given {invite_user user, entity, :admin}
+
+      When(:result) {entity.invite user, :user}
+
+      Then  { expect(result).to have_failed(Invitational::AlreadyInvitedError) }
+    end
+
+    context "Users cannot be invited with a role that isn't defined on the entity" do
+      When(:result) {entity.invite user, :client}
+
+      Then  { expect(result).to have_failed(Invitational::InvalidRoleError) }
+    end
+  end
+
+  context "cleans up invitations when an entity is deleted" do
+    Given! (:invite) {invite_user user, entity, :admin}
+    Given {entity.destroy}
+
+    When (:result) {Invitation.find(invite.id)}
+
+    Then {expect(result).to have_failed(ActiveRecord::RecordNotFound)}
+  end
+
+end

data/spec/invitational/models/invitation_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+require 'invitational/services/service_helper'
+
+describe Invitational::Invitation do
+  Given {no_invitations_exist}
+
+  Given(:user1) { setup_user "test1@d-i.co" }
+  Given(:user2) { setup_user "test2@d-i.co" }
+  Given(:user3) { setup_user "test3@d-i.co" }
+  Given(:user4) { setup_user "test4@d-i.co" }
+  Given(:user5) { setup_user "test5@d-i.co" }
+
+  Given(:entity1) { setup_entity "Test entity 1"}
+  Given(:entity2) { setup_entity "Test entity 2"}
+  Given(:entity3) { setup_entity "Test entity 3"}
+
+  Given (:unclaimed) {invite_by_email user1.email, entity1, :user}
+  Given (:claimed) {invite_user user2, entity2, :admin}
+  Given (:uber_admin) {invite_uber_admin user3}
+
+  context "Initialization" do
+    context "Creates Claim hash and date sent on creation" do
+      Given(:new_invite) {Invitation.new(email: "test999@d-i.co", invitable: entity1, role: :user)}
+
+      When {new_invite.save}
+
+      Then {new_invite.claim_hash.should_not be_nil}
+      And  {new_invite.date_sent.should_not be_nil}
+    end
+  end
+
+  context "Role Title" do
+    context "Standard Role" do
+      Then {unclaimed.role_title.should == "User"}
+    end
+
+    context "Uber Admin" do
+      Then {uber_admin.role_title.should == "Uber Admin"}
+    end
+  end
+
+  context "Type" do
+    context "Standard Role" do
+      Then {unclaimed.uberadmin?.should_not be_true}
+      And  {claimed.uberadmin?.should_not be_true}
+    end
+
+    context "Uber Admin" do
+      Then {uber_admin.uberadmin?.should be_true}
+    end
+  end
+
+  context "Claim Status" do
+    context "Unclaimed" do
+      Then {unclaimed.claimed?.should_not be_true}
+      And  {unclaimed.unclaimed?.should be_true}
+    end
+
+    context "Claimed" do
+      Then {claimed.claimed?.should be_true}
+      And  {claimed.unclaimed?.should_not be_true}
+    end
+  end
+
+  context "Claiming" do
+    context "By Hash" do
+      When (:result) {Invitation.claim unclaimed.claim_hash, user1}
+
+      Then  { result.id.should == unclaimed.id}
+      And   { user1.invitations.should include(result) }
+    end
+
+    context "All for a given user" do
+      Given {invite_by_email user4.email, entity3, :user}
+
+      When (:result) {Invitation.claim_all_for user4}
+
+      Then {user4.entities.should include(entity3)}
+    end
+  end
+
+  context "Invites Uberadmin" do
+    context "By email" do
+      When (:result) {Invitation.invite_uberadmin user4.email}
+
+      Then  {result.should_not be_nil}
+      And   {result.invitable.should be_nil}
+      And   {result.email.should == user4.email}
+      And   {result.role.should == :uberadmin }
+      And   {result.unclaimed?.should be_true}
+    end
+
+    context "Existing user" do
+      When (:result) {Invitation.invite_uberadmin user4}
+
+      Then  {result.should_not be_nil}
+      And   {result.invitable.should be_nil}
+      And   {result.email.should == user4.email}
+      And   {result.role.should == :uberadmin}
+      And   {result.claimed?.should be_true}
+      And   {result.user.should == user4 }
+    end
+
+    context "When already invited" do
+      Given {invite_uber_admin user4}
+
+      When (:result) {Invitation.invite_uberadmin user4}
+
+      Then  { expect(result).to have_failed(Invitational::AlreadyInvitedError) }
+    end
+
+    context "Invites to System Role" do
+      context "By email" do
+        When (:result) {Invitation.invite_system_user user4.email, :employer}
+
+        Then  {result.should_not be_nil}
+        And   {result.invitable.should be_nil}
+        And   {result.email.should == user4.email}
+        And   {result.role.should == :employer }
+        And   {result.unclaimed?.should be_true}
+      end
+
+      context "Existing user" do
+        When (:result) {Invitation.invite_system_user user4, :employer}
+
+        Then  {result.should_not be_nil}
+        And   {result.invitable.should be_nil}
+        And   {result.email.should == user4.email}
+        And   {result.role.should == :employer}
+        And   {result.claimed?.should be_true}
+        And   {result.user.should == user4 }
+      end
+
+      context "When already invited" do
+        Given {invite_system_role user4, :employer}
+
+        When (:result) {Invitation.invite_system_user user4, :employer}
+
+        Then  { expect(result).to have_failed(Invitational::AlreadyInvitedError) }
+      end
+    end
+  end
+
+
+end

data/spec/invitational/models/user_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+require 'invitational/services/service_helper'
+
+describe User do
+  Given {no_invitations_exist}
+
+  Given(:user1) { setup_user "test1@d-i.co" }
+  Given(:user2) { setup_user "test2@d-i.co" }
+  Given(:user3) { setup_user "test2@d-i.co" }
+
+  Given(:entity1) { setup_entity "Test entity 1"}
+
+  context 'invited_to creates a has_many_through relationship' do
+    When {invite_user user1, entity1, :admin}
+
+    Then {user1.entities.should include(entity1)}
+    And  {user1.children.count.should == 0}
+    end
+
+  context 'indicates if a user is an uberadmin' do
+    context 'when an uberadmin' do
+      When {invite_uber_admin user2}
+
+      Then {user2.uberadmin?.should be_true}
+      end
+
+    context 'when not an uberadmin' do
+      When {invite_user user1, entity1, :admin}
+
+      Then {user1.uberadmin?.should_not be_true}
+      end
+  end
+
+  context 'checks to see if a user is invited to a given system role' do
+    context 'when an invited' do
+      When {invite_system_role user2, :employer}
+
+      Then {user2.invited_to_system?(:employer).should be_true}
+    end
+
+    context 'when not invited' do
+      When {invite_user user1, entity1, :admin}
+
+      Then {user1.invited_to_system?(:employer).should_not be_true}
+    end
+  end
+
+  context 'checks to see if a user is invited to a given entity' do
+
+    context 'for any role' do
+      context 'when invited' do
+        When {invite_user user1, entity1, :admin}
+
+        Then {user1.invited_to?(entity1).should be_true}
+      end
+
+      context 'when not invited' do
+        When {invite_user user2, entity1, :admin}
+
+        Then {user1.invited_to?(entity1).should_not be_true}
+      end
+    end
+
+
+    context 'for a specific role' do
+      When {invite_user user1, entity1, :admin}
+
+      context 'when invited' do
+        Then {user1.invited_to?(entity1, :admin).should be_true}
+      end
+
+      context 'when not invited' do
+        Then {user2.invited_to?(entity1, :admin).should_not be_true}
+      end
+
+      context 'when invited to a different role' do
+        Then {user1.invited_to?(entity1, :user).should_not be_true}
+      end
+    end
+
+  end
+
+  context "cleans up invitations when a user is deleted" do
+    Given! (:invite) {invite_user user1, entity1, :admin}
+    Given {user1.destroy}
+
+    When (:result) {Invitation.find(invite.id)}
+
+    Then {expect(result).to have_failed(ActiveRecord::RecordNotFound)}
+  end
+
+  context "creates named scopes for system roles" do
+    context 'when an uberadmin' do
+      When {invite_uber_admin user2}
+      Then {User.uberadmins.should include(user2)}
+      And {User.uberadmins.should_not include(user1)}
+    end
+
+    context 'when an employer' do
+      When {invite_system_role user2, :employer}
+      Then {User.employers.should include(user2)}
+      And {User.employers.should_not include(user1)}
+    end
+  end
+
+end
+

data/spec/invitational/services/checks_for_invitation_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+require 'invitational/services/service_helper'
+
+describe Invitational::ChecksForInvitation do
+  Given {no_invitations_exist}
+
+  Given(:user1) { setup_user "test1@d-i.co" }
+  Given(:user2) { setup_user "test2@d-i.co" }
+  Given(:user3) { setup_user "test3@d-i.co" }
+
+  Given(:entity) { setup_entity "Test entity"}
+
+  Given {invite_user user1, entity, :user}
+  Given {invite_uber_admin user3}
+
+  context "checking for any role" do
+
+    context "when invited" do
+      When(:result) { Invitational::ChecksForInvitation.for user1, entity }
+
+      Then {result.should be_true}
+    end
+
+    context "when not invited" do
+      When(:result) { Invitational::ChecksForInvitation.for user2, entity }
+
+      Then {result.should_not be_true}
+    end
+
+    context "when uber admin" do
+      When(:result) { Invitational::ChecksForInvitation.for user3, entity }
+
+      Then {result.should be_true}
+    end
+
+  end
+
+  context "checking for specific role" do
+    context "when invited in that role" do
+      When(:result) { Invitational::ChecksForInvitation.for user1, entity, :user }
+
+      Then {result.should be_true}
+    end
+
+    context "when invited in another role" do
+      When(:result) { Invitational::ChecksForInvitation.for user1, entity, :admin }
+
+      Then {result.should_not be_true}
+    end
+
+    context "when not invited" do
+      When(:result) { Invitational::ChecksForInvitation.for user2, entity, :user }
+
+      Then {result.should_not be_true}
+    end
+
+    context "when uber admin" do
+      When(:result) { Invitational::ChecksForInvitation.for user3, entity, :user }
+
+      Then {result.should be_true}
+    end
+  end
+
+  context "checking for any of an array of roles" do
+    context "when invited to one of the roles" do
+      When(:result) { Invitational::ChecksForInvitation.for user1, entity, [:user, :admin] }
+
+      Then {result.should be_true}
+    end
+
+    context "when invited in another role" do
+      When(:result) { Invitational::ChecksForInvitation.for user1, entity, [:none, :admin] }
+
+      Then {result.should_not be_true}
+    end
+
+    context "when not invited" do
+      When(:result) { Invitational::ChecksForInvitation.for user2, entity, [:user, :admin] }
+
+      Then {result.should_not be_true}
+    end
+
+    context "when uber admin" do
+      When(:result) { Invitational::ChecksForInvitation.for user3, entity, [:user, :admin] }
+
+      Then {result.should be_true}
+    end
+
+  end
+
+end

data/spec/invitational/services/claims_all_invitations_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'invitational/services/service_helper'
+
+describe Invitational::ClaimsAllInvitations do
+  Given {no_invitations_exist}
+
+  Given(:user) { setup_user "test@d-i.co" }
+  Given(:entity1) { setup_entity "Test entity 1"}
+  Given(:entity2) { setup_entity "Test entity 2"}
+
+  context "with pending invitation for email" do
+    Given!(:invitation1) {invite_by_email user.email, entity1, :user}
+    Given!(:invitation2) {invite_by_email user.email, entity2, :user}
+
+    When { Invitational::ClaimsAllInvitations.for user }
+
+    Then { user.invitations.should include(invitation1) }
+    And  { user.invitations.should include(invitation2) }
+  end
+
+  context "with pending invitation for another email" do
+    Given!(:invitation) {invite_by_email "foo@d-i.co", entity1, :user}
+
+    When { Invitational::ClaimsAllInvitations.for user }
+
+    Then { user.invitations.should_not include(invitation) }
+  end
+
+end

data/spec/invitational/services/claims_invitation_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'invitational/services/service_helper'
+
+describe Invitational::ClaimsInvitation do
+  Given {no_invitations_exist}
+
+  Given(:user) { setup_user "test@d-i.co" }
+  Given(:entity) { setup_entity "Test entity"}
+
+  context "for unclaimed invitation" do
+    context "invitation is to the user's email" do
+      Given!(:invitation) {invite_by_email user.email, entity, :admin}
+
+      When (:result) { Invitational::ClaimsInvitation.for invitation.claim_hash, user }
+
+      Then  { result.should == invitation}
+      And   { user.invitations.should include(invitation) }
+    end
+
+    context "invitation is to another email" do
+      Given!(:invitation) {invite_by_email "foo@d-i.co", entity, :admin}
+
+      When (:result) { Invitational::ClaimsInvitation.for invitation.claim_hash, user }
+
+      Then  { result.should == invitation}
+      And   { user.invitations.should include(invitation) }
+    end
+  end
+
+  context "for claimed invitation" do
+    Given(:user2) {setup_user "foo@bar.com"}
+    Given(:invitation) {invite_user user2, entity, :admin}
+
+    When (:result) { Invitational::ClaimsInvitation.for invitation.claim_hash, user }
+
+    Then  { expect(result).to have_failed(Invitational::AlreadyClaimedError) }
+    And   { user.invitations.should_not include(invitation) }
+  end
+
+  context "If the invitation hash is bad" do
+    Given!(:invitation) {invite_by_email user.email, entity, :admin}
+
+    When (:result) { Invitational::ClaimsInvitation.for "THIS_IS_A_BAD_HASH", user }
+
+    Then  { expect(result).to have_failed(Invitational::InvitationNotFoundError) }
+    And   { user.invitations.should_not include(invitation) }
+  end
+
+end

data/spec/invitational/services/creates_invitation_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'invitational/services/service_helper'
+
+describe Invitational::CreatesInvitation do
+  Given {no_invitations_exist}
+
+  Given(:entity) { setup_entity "Test Entity"}
+
+  context "by email" do
+
+    context "when not already invited" do
+      When (:result) {Invitational::CreatesInvitation.for entity, "test@d-i.co", :admin}
+
+      Then  {result.should_not be_nil}
+      And   {result.invitable.should == entity}
+      And   {result.email.should == "test@d-i.co"}
+      And   {result.role.should == :admin}
+      And   {result.unclaimed?.should be_true}
+    end
+
+    context "when already invited" do
+      Given {::Invitation.new(invitable: entity, role: :admin, email: 'test@d-i.co').save}
+
+      When (:result) {Invitational::CreatesInvitation.for entity, "test@d-i.co", :admin}
+
+      Then  { expect(result).to have_failed(Invitational::AlreadyInvitedError) }
+    end
+
+  end
+
+  context "to be immediately claimed" do
+    Given(:user) { setup_user "test@d-i.co" }
+
+    context "when not already invited" do
+      When (:result) {Invitational::CreatesInvitation.for entity, user, :admin}
+
+      Then  {result.should_not be_nil}
+      And   {result.invitable.should == entity}
+      And   {result.email.should == "test@d-i.co"}
+      And   {result.role.should == :admin}
+      And   {result.claimed?.should be_true}
+      And   {result.user.should == user }
+    end
+
+    context "when already invited" do
+      Given {::Invitation.new(invitable: entity, role: :admin, email: 'test@d-i.co', user: user).save}
+
+      When (:result) {Invitational::CreatesInvitation.for entity, user, :admin}
+
+      Then  { expect(result).to have_failed(Invitational::AlreadyInvitedError) }
+    end
+
+  end
+
+end

data/spec/invitational/services/creates_system_user_invitation_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'invitational/services/service_helper'
+
+describe Invitational::CreatesSystemUserInvitation do
+  Given {no_invitations_exist}
+
+  context "by email" do
+    context "when not already invited" do
+      When (:result) {Invitational::CreatesSystemUserInvitation.for "test@d-i.co", :employer}
+
+      Then  {result.should_not be_nil}
+      And   {result.invitable.should be_nil}
+      And   {result.email.should == "test@d-i.co"}
+      And   {result.role.should == :employer }
+      And   {result.unclaimed?.should be_true}
+    end
+
+    context "when already invited" do
+      Given {::Invitation.new(role: :employer, email: 'test@d-i.co').save}
+
+      When (:result) {Invitational::CreatesSystemUserInvitation.for "test@d-i.co", :employer}
+
+      Then  { expect(result).to have_failed(Invitational::AlreadyInvitedError) }
+    end
+
+  end
+
+  context "to be immediately claimed" do
+    Given(:user) { setup_user "test2@d-i.co" }
+
+    context "when not already invited" do
+      When (:result) {Invitational::CreatesSystemUserInvitation.for user, :employer}
+
+      Then  {result.should_not be_nil}
+      And   {result.invitable.should be_nil}
+      And   {result.email.should == "test2@d-i.co"}
+      And   {result.role.should == :employer}
+      And   {result.claimed?.should be_true}
+      And   {result.user.should == user }
+    end
+
+    context "when already invited" do
+      Given {::Invitation.new(role: :employer, email: 'test2@d-i.co', user: user).save}
+
+      When (:result) {Invitational::CreatesSystemUserInvitation.for user, :employer}
+
+      Then  { expect(result).to have_failed(Invitational::AlreadyInvitedError) }
+    end
+
+  end
+
+end