your_platform 0.0.1 → 0.0.2

data/spec/models/structureable_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+# We use the Page model here as an example, since it is already represented in the database.
+#
+#   class Page < ActiveRecord::Base
+#     is_structureable ...
+#     ...
+#   end
+
+describe Structureable do
+
+  describe ".is_structureable" do
+
+    before { @node = create( :page ) }
+    subject { @node }
+
+    it "should provide the has_dag_links functionality" do
+      subject.should respond_to( :parents, :children, :ancestors, :descendants )
+    end
+
+    it "should provide the has_many_flags functionality" do
+      subject.should respond_to( :flags, :add_flag, :remove_flag )
+    end
+
+    it "should make sure that when objects are destroyed, also their dag links are destroyed" do
+      @parent = create( :page )
+      @parent.child_pages << @node
+      @node.destroy
+      @parent.links_as_parent.count.should == 0
+    end
+
+  end
+  
+  describe "#move_to" do
+    subject { @node.move_to @new_parent }
+    
+    before do
+      @parent = create :group
+      @new_parent = create :group
+      @user = create :user
+    end
+    
+    [:group, :page, :event, :user].each do |kind_of_node|
+      describe "for a #{kind_of_node} node" do
+       
+        before { @node = create kind_of_node }
+        
+        describe "if the node has no parent" do
+          it "should should set the given parent as parent node" do
+            @node.parents.should == []
+            subject
+            @node.reload.parents.should == [@new_parent]
+          end
+        end
+        describe "if the node has one parent" do
+          before { @parent << @node }
+          it "should remove the old relation" do
+            @node.parents.should == [@parent]
+            subject
+            @node.reload.parents.should_not include @parent
+          end
+        end
+        describe "if the new parent is the old parent" do
+          before do
+            @parent << @node
+            @new_parent = @parent
+          end
+          it "should not change the existing relation" do
+            @links_before = @node.links_as_child
+            subject
+            @node.reload.links_as_child.should == @links_before
+          end
+        end
+      
+      end
+    end
+    
+    describe "moving a group from a group to a page" do
+      before do
+        @node = create :group
+        @parent = create :group
+        @new_parent = create :page
+        @parent << @node
+      end
+      it "should move the object without error" do
+        @node.parents.should == [@parent]
+        subject
+        @node.reload.parents.should_not include @parent
+      end
+      
+      describe "when the node has a child user" do
+        before { @node << @user }
+        it "should keep the group-user relation" do
+          subject
+          @node.child_users.should == [@user]
+        end
+        it "should create an ancestor relation between the new parent and the child user" do
+          subject
+          @user.reload.ancestors.should include @new_parent
+          @user.ancestors.should_not include @parent
+        end
+      end
+    end
+    
+    describe "moving a group from a group to another group" do
+      before do
+        @node = create :group
+        @parent = create :group
+        @new_parent = create :group
+        @parent << @node
+      end
+      
+      describe "when the node has a child user" do
+        before { @node << @user }
+        describe "when the child user is already a child of the new parent" do
+          before { @new_parent << @user }
+          it "should still work" do
+            @user.ancestors.should include @new_parent
+            subject
+            @user.reload.ancestors.should include @new_parent, @node
+            @user.ancestors.should_not include @parent
+          end
+        end
+      end
+    end
+    
+  end
+end

data/spec/models/user_account_spec.rb

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe UserAccount do
+
+  before do
+    @user = create(:user_with_account)
+    @account = @user.account
+  end
+
+  specify "the account should exist at this point" do
+    @account.should be 
+  end
+
+  describe "#user" do
+    subject { @account.user }
+    it { should == @user } 
+  end
+
+  describe "#id" do
+    subject { @account.id }
+    it { should_not be_nil }
+  end
+
+  describe "#encrypted_password" do
+    subject { @account.encrypted_password }
+    describe "just after creating the account" do
+      it { should_not be_nil }
+    end
+    describe "after reloading the account from the database" do
+      subject { User.find(@user.id).account.encrypted_password }
+      it { should_not be_nil }
+    end
+  end
+
+  describe "#password" do
+    subject { @account.password }
+    describe "just after creating the account" do
+      it { should be_kind_of String }
+      it { should be_present }
+    end
+    describe "after reloading the account from the database" do
+      subject { User.find(@user.id).account.password }
+      describe "in order to protect the password from being read out" do
+        it { should == nil }
+      end
+    end
+  end
+
+  describe '#email=' do
+    it 'should not raise an exception when set because it is required by devise for an error case' do
+      expect{@account.email = 'invalid@example.org'}.to_not raise_error
+    end
+  end
+
+  describe '#identify_user_account' do
+    describe 'with invalid login name' do
+      it 'should return nil' do
+        UserAccount.identify('invalid').should be_nil
+      end
+    end
+
+    describe 'with valid email' do
+      it 'should return the user account' do
+        expect(UserAccount.identify(@user.email)).to eq(@account)
+      end
+    end
+
+    describe 'with valid alias' do
+      it 'should return the user account' do
+        expect(UserAccount.identify(@user.alias)).to eq(@account)
+      end
+    end
+
+    describe 'with valid name' do
+      it 'should return the user account' do
+        expect(UserAccount.identify(@user.name)).to eq(@account)
+      end
+    end
+  end
+
+  describe "#auth_token" do
+    subject { @account.auth_token }
+    describe "just after creating the account" do
+      it { should be_present }
+      it { should be_kind_of String }
+      its(:length) { should >= 40 }
+    end
+    specify "calling it twice should not change the token" do
+      token1 = subject
+      token2 = subject
+      token1.should == token2
+    end
+  end
+  
+  describe ".identify" do
+    before do
+      @user1 = create :user_with_account, first_name: "John", last_name: "Doe", email: "john.doe@example.com", :alias => "doe"
+      @user2 = create :user_with_account, first_name: "James", last_name: "Doe", email: "james.doe@example.com", :alias => "james.doe"
+    end
+    
+    context "for an empty login string" do
+      it "should return nil" do
+        expect { UserAccount.identify('') == nil }.to be_true
+      end
+    end
+    context "if only one user is matching" do
+      it "should return the one matching user account" do
+        UserAccount.identify("james.doe").should == @user2.account
+        UserAccount.identify("james.doe@example.com").should == @user2.account
+        UserAccount.identify("John Doe").should == @user1.account
+      end
+    end
+    context "for multiple users with the same last name" do
+      before { @user1.update_attributes(:alias => nil) }
+      it "should raise an error" do
+        expect { UserAccount.identify('doe') }.to raise_error 'identification_not_unique'
+      end
+    end
+    context "if the last name is identical to the alias (bug fix)" do
+      before do
+        @user1.destroy # since only @user2 should be present for this test 
+        @user2.update_attribute(:alias, 'doe')
+      end
+      specify "prerequisites" do
+        @user2.alias.downcase.should == @user2.last_name.downcase
+      end
+      it "should return the one matching user" do
+        UserAccount.identify('doe').should == @user2.account
+      end
+    end
+    context "for several users having the same last name and one of them having the last name as alias (bug fix)" do
+      specify "prerequisites" do
+        @user1.last_name.downcase.should == @user1.alias.downcase
+        @user2.last_name.downcase.should == @user1.last_name.downcase
+      end
+      it "should return the user identified by the alias" do
+        UserAccount.identify("doe").should == @user1.account
+      end
+    end
+  end
+end

data/spec/models/user_alias_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe UserAlias do
+
+  describe ".taken?(alias)" do
+    subject { UserAlias.taken?("j.doe") }
+    describe "for the alias not being taken" do
+      it { should be_false }
+    end
+    describe "for the alias being taken" do
+      before { @user = create(:user, :alias => "j.doe" ) }
+      it { should_not be_false }
+      it { should == @user }
+    end
+  end
+
+  describe "#taken?" do
+    subject { UserAlias.new("foo").taken? }
+    describe "for the alias not being taken" do
+      it { should == false }
+    end
+    describe "for the alias being taken" do
+      before { @user = create(:user, :alias => "foo") }
+      it { should_not be_false }
+      it { should == @user }
+    end
+  end
+
+  describe ".generate_for(user)" do
+    before do
+      @user = create(:user, first_name: "John", last_name: "Doe")
+    end
+    subject { UserAlias.generate_for(@user) }
+    describe "for no other user with the same last name existing" do
+      it { should == "doe" }
+    end
+    describe "for a user with the same last name existing" do
+      before { create(:user, first_name: "Otto", last_name: "Doe") }
+      it { should == "j.doe" }
+    end
+    describe "for a user with the same last name and a first name with the same initial existing" do
+      before { create(:user, first_name: "Jane", last_name: "Doe") }
+      it { should == "john.doe" }
+    end
+    describe "for a user with the same first and last names existing" do
+      before { create(:user, first_name: "John", last_name: "Doe", :alias => "some_other_alias") }
+      describe "for the user having a date of birth given" do
+        before { @user.date_of_birth = "1986-01-01".to_date }
+        it { should == "john.doe.1986" }
+      end
+      describe "for the user having no date of birth given" do
+        it { should == nil }
+      end
+    end
+  end
+
+end

data/spec/models/user_group_membership_mixins/validity_range_for_indirect_memberships_spec.rb

@@ -0,0 +1,291 @@
+require 'spec_helper'
+
+describe UserGroupMembershipMixins::ValidityRangeForIndirectMemberships do
+
+  # Memberships:
+  #
+  #       *-----------------(c)--------------------*
+  #                          |
+  #                |--------------------|
+  #                |                    |
+  #       *-------(a)--------*          | 
+  #                          *---------(b)---------*
+  #
+  #       _________________________________________________________
+  #       t1                 t2                    t3      time -->
+  #
+  # Structure:
+  #
+  #       indirect_group ........................... (c)
+  #             |---------- direct_group ........... (a), (b)
+  #                              |--------- user
+  #       
+  before do
+    @user = create(:user)
+    @indirect_group = create(:group)
+    @direct_group_a = @indirect_group.child_groups.create
+    @direct_group_b = @indirect_group.child_groups.create    
+    @direct_group_a.assign_user @user
+    @indirect_membership = UserGroupMembership.find_by_user_and_group(@user, @indirect_group)
+    @direct_membership_a = UserGroupMembership.find_by_user_and_group(@user, @direct_group_a)
+    @direct_membership_b = @direct_membership_a.move_to_group(@direct_group_b)
+    @t1 = 2.hours.ago
+    @t2 = 1.hour.ago
+    @t3 = nil
+    @direct_membership_a.update_attribute(:valid_from, @t1)
+    @direct_membership_a.update_attribute(:valid_to, @t2)
+    @direct_membership_b.update_attribute(:valid_from, @t2)
+    @direct_membership_b.update_attribute(:valid_to, @t3)
+  end
+  
+  specify "preliminaries" do
+    @direct_membership_a.valid_from.to_i.should < @direct_membership_b.valid_from.to_i
+    
+    #@direct_membership_a.valid_to.should < @direct_membership_b.valid_to
+  end
+  
+  
+  # Validity Range Attributes
+  # ====================================================================================================
+  
+  describe "#valid_from" do
+    subject { @indirect_membership.valid_from }
+    it "should be the valid_from attribute of the earliest direct membership" do
+      subject.to_i.should == @direct_membership_a.valid_from.to_i
+    end
+  end
+  describe "#valid_from=" do
+    before { @time = 30.minutes.ago }
+    subject { @indirect_membership.valid_from = @time }
+    it "should set the valid_from  attribute of the earliset direct membership" do
+      subject
+      @indirect_membership.save
+      @direct_membership_a.reload.valid_from.to_i.should == @time.to_i
+    end
+  end
+  
+  describe "#valid_to" do
+    subject { @indirect_membership.valid_to }
+    it "should be the valid_to attribute of the latest direct membership" do
+      subject.to_i.should == @direct_membership_b.valid_to.to_i
+    end
+  end
+  describe "#valid_to=" do
+    before { @time = 30.minutes.ago }
+    subject { @indirect_membership.valid_to = @time }
+    it "should set the valid_to addtirbute of the last direct membership" do
+      subject
+      @indirect_membership.save
+      @direct_membership_b.reload.valid_to.to_i.should == @time.to_i
+    end
+  end
+  
+  describe "#earliest_direct_membership" do
+    subject { @indirect_membership.earliest_direct_membership }
+    it { should == @direct_membership_a }
+  end
+  
+  describe "#latest_direct_membership" do
+    subject { @indirect_membership.latest_direct_membership }
+    it { should == @direct_membership_b }
+  end
+  
+  describe "#recalculate_validity_range_from_direct_memberships" do
+    before do
+      @t1 = 10.hours.ago; @t2 = 8.hours.ago; @t3 = 37.minutes.ago
+      @direct_membership_a.update_attribute(:valid_from, @t1)
+      @direct_membership_a.update_attribute(:valid_to, @t2)
+      @direct_membership_b.update_attribute(:valid_from, @t2)
+      @direct_membership_b.update_attribute(:valid_to, @t3)
+    end
+    subject { @indirect_membership.recalculate_validity_range_from_direct_memberships; @indirect_membership.reload }
+    it "should make the indirect validity range match the direct memberships' combined range" do
+      subject
+      @indirect_membership.valid_from.to_i.should == @t1.to_i
+      @indirect_membership.valid_to.to_i.should == @t3.to_i
+    end
+    it "should write the indirect ranges to the database" do
+      subject
+      @indirect_membership.read_attribute(:valid_from).to_i.should == @t1.to_i
+      @indirect_membership.read_attribute(:valid_to).to_i.should == @t3.to_i
+    end
+    it "should persist in the graph" do
+      subject
+      DagLink.find(@indirect_membership.id).valid_from.to_i.should == @t1.to_i
+      DagLink.find(@indirect_membership.id).valid_to.to_i.should == @t3.to_i
+    end
+    describe "for the earliest valid_from being nil" do
+      before { @direct_membership_a.update_attribute(:valid_from, nil) }
+      specify "prelims" do
+        @reloaded_direct_membership_a = UserGroupMembership.with_invalid.find(@direct_membership_a.id)
+        @reloaded_direct_membership_a.read_attribute(:valid_from).should == nil
+      end
+      it "should set the indirect valid_from to nil" do
+        subject
+        @indirect_membership.read_attribute(:valid_from).should == nil
+      end
+    end
+    describe "(bug fix: reproducing status group membership scenario)" do
+      #   @corporation
+      #        |------- @intermediate_group
+      #                         |------------ @status_group
+      #                         |                  |--------- (@user)
+      #                         | 
+      #                         |------------ @second_status_group
+      #                                            |--------- @user
+      before do
+        @corporation = create( :corporation, name: "Corporation" )
+        @intermediate_group = create( :group, name: "Not a Status Group" )
+        @status_group = create( :group, name: "Status Group" )
+        @intermediate_group.parent_groups << @corporation
+        @status_group.parent_groups << @intermediate_group
+        @user = create( :user )
+        @status_group.assign_user @user
+        @membership = UserGroupMembership.find_by_user_and_group( @user, @status_group )
+        @intermediate_group_membership = UserGroupMembership
+          .find_by_user_and_group( @user, @intermediate_group )
+        @second_status_group = @intermediate_group.child_groups.create(name: "Second Status Group")
+        @membership.update_attribute(:valid_from, 1.year.ago)
+        @corpo_membership = UserGroupMembership.find_by_user_and_group(@user, @corporation)
+      end
+      specify "prelims" do
+        @user.should be_kind_of User
+        @corporation.reload.should be_kind_of Corporation
+        @corporation.descendants.should include @intermediate_group, @status_group, @second_status_group, @user
+        @intermediate_group.reload.descendants.should include @status_group, @second_status_group, @user
+        @status_group.reload.descendants.should include @user
+      end
+      describe "promoting the membership" do
+        subject { @second_membership = @membership.move_to(@second_status_group, at: 20.day.ago) }
+        # @membership          valid_from: 1.year.ago,   valid_to: 20.days.ago
+        # @second_membership   valid_from: 20.days.ago,  valid_to: nil
+        # @corpo_membership    valid_from: 1.year.ago,   valid_to: nil
+        before { subject }
+
+        it "should update the valid_from and valid_to of the indirect membership" do
+          @corpo_membership.read_attribute(:valid_from).to_date.should == 1.year.ago.to_date
+          @corpo_membership.read_attribute(:valid_to).should == nil
+        end
+        it "should update the validity range persistent" do
+          @reloaded_corpo_membership = UserGroupMembership.find(@corpo_membership.id)
+          @reloaded_corpo_membership.should == @corpo_membership
+          @reloaded_corpo_membership.valid_from.to_date.should == 1.year.ago.to_date
+          @reloaded_corpo_membership.valid_to.should == nil
+        end
+        it "should update the valid_from and valid_to of the corresponding graph link" do
+          @link = DagLink.find(@corpo_membership.id)
+          @link.valid_from.to_date.should == 1.year.ago.to_date
+          @link.valid_to.should == nil
+        end
+        it "should update the graph structure" do
+          @second_status_group.reload.descendants.should include @user
+          @corporation.reload.descendants.should include @user
+        end
+        it "should update the corporation members correctly" do
+          @corporation.members.should include @user
+          @user.should be_member_of @corporation
+        end
+        specify "the corporation members should match the memberships in number" do
+          @corporation.memberships.count.should > 0
+          @corporation.memberships.count.should == @corporation.members.count
+        end
+        specify "the indirect membership should be included in the memberships associated with the corporation" do
+          @corporation.memberships.should include @corpo_membership
+        end
+        it "should make no difference if the validity range is forcefully updated" do
+          @corpo_membership.read_attribute(:valid_from).to_date.should == 1.year.ago.to_date
+          @corpo_membership.read_attribute(:valid_to).should == nil
+
+          @membership.update_attribute(:valid_from, 1.year.ago)
+          @membership.update_attribute(:valid_to, 20.days.ago)
+          @second_membership.update_attribute(:valid_from, 20.days.ago)
+          @second_membership.update_attribute(:valid_to, nil)
+
+          @corpo_membership = UserGroupMembership.find(@corpo_membership.id)
+          @corpo_membership.read_attribute(:valid_from).to_date.should == 1.year.ago.to_date
+          @corpo_membership.read_attribute(:valid_to).should == nil
+        end
+      end
+    end
+  end
+  
+    
+  # Invalidation
+  # ====================================================================================================
+  
+  describe "#make_invalid" do
+    subject { @indirect_membership.make_invalid }
+    it "should raise an error" do
+      expect { subject }.to raise_error
+    end
+  end
+  describe "#invalidate" do
+    subject { @indirect_membership.invalidate }
+    it "should raise an error" do
+      expect { subject }.to raise_error
+    end
+  end
+
+  
+  # Validity Check
+  # ====================================================================================================
+  
+  describe "#valid_at?(time)" do
+    subject { @indirect_membership.valid_at? @time_to_check }
+    specify "preliminaries" do
+      @indirect_membership.earliest_direct_membership.valid_from.to_i.should == @t1.to_i
+      @indirect_membership.earliest_direct_membership.valid_to.to_i.should == @t2.to_i
+      @indirect_membership.latest_direct_membership.valid_from.to_i.should == @t2.to_i
+      @indirect_membership.latest_direct_membership.valid_to.should == @t3
+    end
+    it "should return false before the early direct membership" do
+      @time_to_check = 3.hours.ago
+      subject.should == false
+    end
+    it "should return true for the duration of the early direct membership" do
+      @time_to_check = 1.5.hours.ago
+      subject.should == true
+    end
+    it "should return true for the duration of the late direct membership" do
+      @time_to_check = 0.5.hours.ago
+      subject.should == true
+    end
+  end
+  
+  
+  # Temporal scopes
+  # ====================================================================================================
+  
+  describe "#at_time" do
+    subject { UserGroupMembership.find_all_by_user(@user).at_time(30.minutes.ago) }
+    specify "preliminaries" do
+      @direct_membership_a.valid_from.to_i.should == @t1.to_i
+      @direct_membership_a.valid_to.to_i.should == @t2.to_i
+      @direct_membership_b.valid_from.to_i.should == @t2.to_i
+      @direct_membership_b.valid_to.should == @t3
+      @indirect_membership.valid_from.to_i.should == @t1.to_i
+      @indirect_membership.valid_to.should == @t3
+      # @indirect_membership.read_attribute(:valid_from).to_i.should == @t1.to_i
+      # @indirect_membership.read_attribute(:valid_to).should == @t3
+    end
+    it "should find the direct membership" do
+      subject.should include @direct_membership_b
+    end
+    it "should find the indirect membership as well" do
+      subject.should include @indirect_membership
+    end
+  end
+  
+  describe "#only_valid" do
+    subject { UserGroupMembership.only_valid.find_all_by_user(@user) }
+    it "should find the valid indirect memberships" do
+      subject.should include @indirect_membership
+    end
+    it "should not find the invalid indirect memberships" do
+      @direct_membership_b.invalidate at: 20.minutes.ago
+      subject.should_not include @indirect_membership
+    end
+  end
+  
+
+end