ucb_confluence 0.0.2

data/lib/confluence/version.rb

@@ -0,0 +1,3 @@
+module Confluence
+  VERSION = "0.0.2"
+end

data/spec/confluence/config_spec.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+
+describe Confluence::Config do
+  before(:all) do
+    @config_yml = "#{Confluence.root()}/config/config.yml"
+  end
+
+  
+  it "should load its configuration" do
+    config = Confluence::Config.new(@config_yml)
+    config[:server_url].should match(/http/)
+    config[:ldap_url].should match(/ldap/)
+    config[:username].should_not be_nil
+    config[:password].should_not be_nil
+    config[:user_default_password].should_not be_nil
+  end
+end

data/spec/confluence/confluence_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+
+describe Confluence do
+  before(:all) do
+    Confluence.config = Confluence::Config.new("#{Confluence.root()}/config/config.yml")
+  end
+  
+  
+  it "should initialize" do
+    Confluence.conn.should be_a(Confluence::Conn)
+  end
+  
+  it "should set ROOT" do
+    File.expand_path(File.dirname(__FILE__) + '/../../').should == Confluence.root()
+  end
+
+  it "should configure logging" do
+    Confluence.logger.should_not be_nil
+  end
+end

data/spec/confluence/conn_spec.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+
+describe Confluence::Conn do
+  it "should connect to confluence" do
+    config = Confluence::Config.new("#{Confluence.root()}/config/config.yml")
+    Confluence::Conn.new(config).should be_a(Confluence::Conn)
+  end
+end

data/spec/confluence/group_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+
+describe Confluence::Group do
+  before(:all) do
+    Confluence.config = Confluence::Config.new("#{Confluence.root()}/config/config.yml")
+    Confluence::Group.delete("atestgroup") if Confluence::Group.all.include?("atestgroup")
+  end
+
+  
+  it "should get all groups" do
+    Confluence::Group.all.should_not be_empty
+  end
+  
+  context "create()" do
+    it "should create a group" do
+      Confluence::Group.all.should_not include("atestgroup")
+      Confluence::Group.create("atestgroup").should be_true
+      Confluence::Group.all.should include("atestgroup")
+      Confluence::Group.delete("atestgroup")
+      Confluence::Group.all.should_not include("atestgroup")    
+    end
+
+    it "should not create a group if the group already exists" do
+      Confluence::Group.create("atestgroup")
+      Confluence::Group.all.should include("atestgroup")
+      Confluence::Group.create("atestgroup").should be_false
+      Confluence::Group.delete("atestgroup")
+    end
+  end
+  
+  context "delete()" do
+    it "should delete a group" do
+      Confluence::Group.create("atestgroup")
+      Confluence::Group.all.should include("atestgroup")
+      Confluence::Group.delete("atestgroup").should be_true
+      Confluence::Group.all.should_not include("atestgroup")
+    end
+
+    it "should not delete a group if the group does not exist" do
+      Confluence::Group.all.should_not include("atestgroup")
+      Confluence::Group.delete("atestgroup").should be_false
+    end        
+  end
+end

data/spec/confluence/jobs/disable_expired_users_spec.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+
+describe Confluence::Jobs::DisableExpiredUsers do
+  before(:all) do
+    Confluence.config = Confluence::Config.new("#{Confluence.root()}/config/config.yml")    
+  end
+  
+  before(:each) do
+    @job = Confluence::Jobs::DisableExpiredUsers.new
+
+    user = Confluence::User.find_by_name("n1")
+    user.delete() if user
+    
+    @user = Confluence::User.new({:name => "n1", :fullname => "fn1", :email => "e@b.e"})
+  end
+
+  after(:each) do
+    @user.delete()
+  end
+  
+
+  context "#disable_expired_users()" do
+    it "should disable users no longer in LDAP" do
+      @user.save()      
+      @job.stub!(:confluence_user_names).and_return([@user.name])
+      @job.stub!(:find_in_confluence).and_return(@user)
+      @job.stub!(:find_in_ldap).and_return(nil)
+      
+      @user.disabled?.should be_false
+      @job.disable_expired_users()
+      @user.disabled?.should be_true
+      @user.groups.should be_empty
+    end
+    
+    it "should disable user's LDAP considers expired" do
+      ldap_user = mock("user1", {:ldap_uid => "n1", :first_name => "f1",
+                                 :last_name => "l1", :email => "e1"})
+      @user.save()      
+      @job.stub!(:confluence_user_names).and_return([@user.name])
+      @job.stub!(:find_in_confluence).and_return(@user)
+      @job.stub!(:find_in_ldap).and_return(ldap_user)
+      @job.stub!(:eligible_for_confluence?).and_return(false)
+      
+      @user.disabled?.should be_false
+      @job.disable_expired_users()
+      @user.disabled?.should be_true
+      @user.groups.should be_empty
+    end
+  end
+end

data/spec/confluence/jobs/ist_ldap_sync_spec.rb

@@ -0,0 +1,77 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+
+describe Confluence::Jobs::IstLdapSync do
+  before(:all) do
+    Confluence.config = Confluence::Config.new("#{Confluence.root()}/config/config.yml")    
+  end
+  
+  before(:each) do
+    @job = Confluence::Jobs::IstLdapSync.new
+
+    user = Confluence::User.find_by_name("n1")
+    user.delete() if user
+    
+    @user = Confluence::User.new({:name => "n1", :fullname => "fn1", :email => "e@b.e"})
+  end
+
+  after(:each) do
+    @user.delete()
+  end
+  
+
+  context "#sync_ist_from_ldap()" do
+    it "should add IST users found in LDAP to Confluence" do
+      ldap_user = mock("user1", {:uid => "n1", :first_name => "f1",
+                                 :last_name => "l1", :email => "e1"})
+      @job.stub!(:ist_people).and_return([ldap_user])
+      @job.stub!(:eligible_for_confluence?).and_return(true)
+      @job.stub!(:find_or_new_user).and_return(@user)
+      
+      Confluence::User.exists?(@user.name).should be_false
+      @job.sync_ist_from_ldap()
+      @user = Confluence::User.find_by_name(@user.name)
+      @user.groups.should have(2).records
+      @user.groups.should include(Confluence::User::DEFAULT_GROUP)
+      @user.groups.should include(Confluence::Jobs::IstLdapSync::IST_GROUP)
+    end
+    
+    it "should give new IST users found in LDAP membership to the IST_GROUP" do
+      ldap_user = mock("user1", {:uid => "n1", :first_name => "f1",
+                                 :last_name => "l1", :email => "e1"})
+      @job.stub!(:ist_people).and_return([ldap_user])
+      @job.stub!(:eligible_for_confluence?).and_return(true)
+      @job.stub!(:find_or_new_user).and_return(@user)
+
+      
+      @user.save()
+      Confluence::User.exists?(@user.name).should be_true
+      @user.groups.should have(1).record
+      @user.groups.should include(Confluence::User::DEFAULT_GROUP)
+      
+      @job.sync_ist_from_ldap()
+      @user.groups.should have(2).records
+      @user.groups.should include(Confluence::User::DEFAULT_GROUP)
+      @user.groups.should include(Confluence::Jobs::IstLdapSync::IST_GROUP)
+    end
+  end
+  
+  
+  context "#sync_ist_from_confluence()" do
+    it "should remove users from IST group" do
+      ldap_user = mock("user1", {:uid => "n1", :first_name => "f1",
+                                 :last_name => "l1", :email => "e1"})
+      @user.save()      
+      @job.stub!(:confluence_user_names).and_return([@user.name])
+      @job.stub!(:find_in_confluence).and_return(@user)
+      @job.stub!(:find_in_ldap).and_return(ldap_user)
+      @job.stub!(:eligible_for_confluence?).and_return(true)
+      @job.stub!(:in_ist?).and_return(false)
+      
+      @user.disabled?.should be_false
+      @job.sync_ist_from_confluence()
+      @user.groups.should have(1).record
+      @user.groups.should_not include(Confluence::Jobs::IstLdapSync::IST_GROUP)
+    end
+  end  
+end

data/spec/confluence/user_spec.rb

@@ -0,0 +1,221 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+
+describe Confluence::User do
+  before(:all) do
+    Confluence.config = Confluence::Config.new("#{Confluence.root()}/config/config.yml")
+
+    @user = Confluence::User.new({
+      :name => "111111",
+      :fullname => "Test Dude",
+      :email => "test_dude@berkeley.edu"
+    })
+    @user.save
+    
+    @group = "test-group"
+    Confluence::Group.create(@group)
+  end
+
+  after(:all) do
+    @user.delete()
+    Confluence::Group.delete(@group)
+  end
+  
+  it "should find all users" do
+    Confluence::User.all_names.should_not be_empty
+  end
+  
+  it "should initialize a user" do
+    attrs = {:name => 'n', :fullname => 'fn', :email => 'e'}
+    u = Confluence::User.new(attrs)
+    u.name.should == 'n'
+    u.fullname.should == 'fn'
+    u.email.should == 'e'
+    
+    attrs = {'name' => 'n', 'fullname' => 'fn', 'email' => 'e'}
+    u = Confluence::User.new(attrs)
+    u.name.should == 'n'
+    u.fullname.should == 'fn'
+    u.email.should == 'e'
+  end
+  
+  it "should find_by_name" do
+    user = Confluence::User.find_by_name(@user.name)
+    user.should be_a(Confluence::User)
+    user.name.should == @user.name
+    user.email.should == @user.email
+    user.fullname.should == @user.fullname
+  end
+  
+  it "should format when sent to_s" do
+    user = Confluence::User.new(@user)
+    user.to_s.should == "name=#{@user[:name]}, fullname=#{@user[:fullname]}, email=#{@user[:email]}"
+  end
+
+  it "should allow attributes to be access with Hash interface" do
+    name = "111111"
+    fullname = "Test Dude"
+    email = "test_dude@berkeley.edu"
+    @user[:name].should == name
+    @user[:fullname].should == fullname
+    @user[:email].should == email
+
+    @user["name"].should == name
+    @user["fullname"].should == fullname
+    @user["email"].should == email
+
+    @user[:bad_att].should == nil
+  end
+
+  it "should save a user's attributes" do
+    # Confluence::User.find_by_name("name").delete
+    Confluence::User.exists?("name").should_not be_true
+    # New User
+    user = Confluence::User.new({:name => "name", :email => "email", :fullname => "fullname"})
+    user.should be_new_record
+    
+    user.save
+    user.should_not be_new_record
+    user = Confluence::User.find_by_name(user.name)
+    user.should_not be_new_record
+    user.email.should == "email"
+    user.name.should == "name"
+    user.fullname.should == "fullname"
+
+    # Update attributes
+    user.email = "emailx"
+    user.fullname = "fullnamex"
+    user.save
+
+    user = Confluence::User.find_by_name(user.name)
+    user.email.should == "emailx"
+    user.name.should == "name"
+    user.fullname.should == "fullnamex"
+    user.delete
+  end
+end
+
+
+describe Confluence::User, "class methods" do
+  before(:all) do
+    Confluence.config = Confluence::Config.new("#{Confluence.root()}/config/config.yml")
+
+    @user1 = Confluence::User.new({
+      :name => "1",
+      :fullname => "Test Dude",
+      :email => "test_dude@berkeley.edu"
+    })
+    @user1.save()
+
+    @user2 = Confluence::User.new({
+      :name => "2",
+      :fullname => "Test Dude (ACCOUNT DISABLED)",
+      :email => "test_dude@berkeley.edu"
+    })
+    @user2.save()
+  end
+
+  after(:all)do
+    u = Confluence::User.find_by_name("1")
+    u.delete() if u
+
+    u = Confluence::User.find_by_name("2")
+    u.delete() if u
+  end
+
+  context "expired()" do
+    it "should return all users that have disabled accounts" do
+      expired_names = Confluence::User.expired.map { |u| u.name }
+      expired_names.should_not include(@user1.name)
+      expired_names.should include(@user2.name)
+    end
+  end
+
+  context "active()" do
+    it "should return all users that have enabled accounts" do
+      active_names = Confluence::User.active.map { |u| u.name }
+      active_names.should include(@user1.name)
+      active_names.should_not include(@user2.name)
+    end
+  end
+  
+end
+
+
+
+describe Confluence::User, "ldap integration" do
+  before(:all) do
+    Confluence.config = Confluence::Config.new("#{Confluence.root()}/config/config.yml")
+    
+    @ldap_user = "322586"
+    u = Confluence::User.find_by_name(@ldap_user)
+    u.delete if u
+  end
+
+  after(:all)do
+    u = Confluence::User.find_by_name(@ldap_user)
+    u.delete() if u
+  end
+
+  it "should find_or_create_from_ldap" do
+    Confluence::User.find_by_name(@ldap_user).should be_nil
+    Confluence::User.find_or_create_from_ldap(@ldap_user)
+    user = Confluence::User.find_by_name(@ldap_user)
+    user.should_not be_nil
+    UCB::LDAP::Person.should_not_receive(:find_by_uid)
+    Confluence::User.find_or_create_from_ldap(@ldap_user).should_not be_nil
+  end
+
+  it "should raise error if find_or_create_from_ldap can't find user in ldap" do
+    lambda { Confluence::User.find_or_create_from_ldap("q") }.should raise_error
+  end
+end
+
+
+describe Confluence::User, "group management" do
+  before(:all) do
+    Confluence.config = Confluence::Config.new("#{Confluence.root()}/config/config.yml")
+    
+    @user = Confluence::User.new({
+      :name => "111111",
+      :fullname => "Test Dude",
+      :email => "test_dude@berkeley.edu"
+    })
+    @user.save
+    
+    @group = "test-group"
+    Confluence::Group.create(@group)
+  end
+
+  after(:all) do
+    @user.delete
+    Confluence::Group.delete(@group)
+  end
+  
+  it "should return a user's groups" do
+    @user.should have(1).groups
+  end
+
+  it "should add a user to a group" do
+    @user.groups.should_not include(@group)
+    @user.join_group(@group).should be_true
+    @user.groups.should include(@group)
+    @user.leave_group(@group)
+  end
+  
+  it "should gracefully handle bad groups names for join_group" do
+    @user.join_group("badgroup").should be_false
+  end
+
+  context "leave_group()" do
+    it "should be false if user is not in the group" do
+      @user.leave_group("badgroup").should be_false
+    end
+    
+    it "should be true if user is in the group" do
+      @user.join_group(@group)
+      @user.leave_group(@group).should be_true
+      @user.groups.should_not include(@group)
+    end
+  end
+end