nakamura 0.1

data/lib/nakamura/test.rb

@@ -0,0 +1,92 @@
+require 'test/unit.rb'
+require 'nakamura'
+require 'nakamura/users'
+require 'nakamura/file'
+require 'nakamura/search'
+require 'tempfile'
+require 'logger'
+
+module SlingTest
+
+  @@log_level = Logger::DEBUG
+
+  def SlingTest.setLogLevel(level)
+    @@log_level = level
+  end
+
+  def setup
+    @s = SlingInterface::Sling.new()
+    @um = SlingUsers::UserManager.new(@s)
+    @search = SlingSearch::SearchManager.new(@s)
+    @created_nodes = []
+    @created_users = []
+    @created_groups = []
+    @delete = true
+    @log = Logger.new(STDOUT)
+    @log.level = @@log_level
+  end
+
+  def teardown
+    if ( @delete ) then
+		@s.switch_user(SlingUsers::User.admin_user)
+		@created_nodes.reverse.each { |n| @s.delete_node(n) }
+		@created_groups.each { |g| @um.delete_group(g) }
+		@created_users.each { |u| @um.delete_user(u.name) }
+	end
+  end
+
+  def create_node(path, props={})
+    #puts "Path is #{path}"
+    res = @s.create_node(path, props)
+    assert_not_equal("500", res.code, "Expected to be able to create node "+res.body)
+    @created_nodes << path
+    return path
+  end
+
+  def create_file_node(path, fieldname, filename, data, content_type="text/plain")
+    res = @s.create_file_node(path, fieldname, filename, data, content_type)
+    @created_nodes << path unless @created_nodes.include?(path)
+    return res
+  end
+
+  def create_user(username, firstname = nil, lastname = nil)
+    u = @um.create_user(username, firstname, lastname)
+    assert_not_nil(u, "Expected user to be created: #{username}")
+    @created_users << u
+    return u
+  end
+
+  def create_test_user(i)
+    u = @um.create_test_user(i)
+    assert_not_nil(u, "Expected user to be created: #{i}")
+    @created_users << u
+    return u
+  end
+
+  def create_group(groupname, title = nil)
+    g = @um.create_group(groupname, title)
+    assert_not_nil(g, "Expected group to be created: #{groupname}")
+    @created_groups << groupname
+    return g
+  end
+
+  def wait_for_indexer()
+    magic_content = "#{Time.now().to_i}_#{rand(1000).to_s}"
+    filename = "wait_for_indexer_#{magic_content}"
+
+    fm = SlingFile::FileManager.new(@s)
+    fm.upload_pooled_file(filename, magic_content, 'text/plain')
+
+    # Give the indexer up to 20 seconds to catch up, but stop waiting early if
+    # we find our test item has landed in the index.
+    20.times do
+      res = @s.execute_get(@s.url_for("/var/search/files/allfiles.json?q=#{filename}"))
+      if JSON.parse(res.body)["total"] != 0
+          break
+      end
+      sleep(1)
+    end
+  end
+
+end
+

data/lib/nakamura/users.rb

@@ -0,0 +1,312 @@
+#!/usr/bin/env ruby
+
+require 'digest/sha1'
+require 'logger'
+
+$USERMANAGER_URI="system/userManager/"
+$GROUP_URI="#{$USERMANAGER_URI}group.create.html"
+$USER_URI="#{$USERMANAGER_URI}user.create.html"
+$DEFAULT_PASSWORD="testuser"
+
+module SlingUsers
+
+  class Principal
+
+    attr_accessor :name
+
+    def initialize(name)
+      @name = name
+    end
+
+
+    # Get the public path for a user
+    def public_path_for(sling)
+      return home_path_for(sling) + "/public"
+    end
+
+    # Get the private path for a user
+    def private_path_for(sling)
+      return home_path_for(sling) + "/private"
+    end
+
+    def message_path_for(sling,messageid,mailbox)
+      #return home_path_for(sling) + "/message/"+messageid[0,2]+"/"+messageid[2,2]+"/"+messageid[4,2]+"/"+messageid[6,2]+"/"+messageid
+      return home_path_for(sling) + "/message/#{mailbox}/#{messageid}"
+    end
+
+  end
+
+
+  class Group < Principal
+    def to_s
+      return "Group: #{@name}"
+    end
+
+    def update_properties(sling, props)
+      return sling.execute_post(sling.url_for("#{group_url}.update.html"), props)
+    end
+
+    def add_member(sling, principal, type)
+      principal_path = "/#{$USERMANAGER_URI}#{type}/#{principal}"
+      return sling.execute_post(sling.url_for("#{group_url}.update.html"),
+              { ":member" => principal_path })
+    end
+
+    def add_members(sling, principals)
+      principal_paths = principals.collect do |principal|
+        if principal.index("g-") == 0
+          type = "group"
+        else
+          type = "user"
+        end
+        "/#{$USERMANAGER_URI}#{type}/#{principal}"
+      end
+      return sling.execute_post(sling.url_for("#{group_url}.update.html"),
+              { ":member" => principal_paths })
+    end
+
+    def add_manager(sling, principal)
+      return sling.execute_post(sling.url_for("#{group_url}.update.html"),
+              { ":manager" => principal })
+    end
+
+    def add_viewer(sling, principal)
+      return sling.execute_post(sling.url_for("#{group_url}.update.html"),
+              { ":viewer" => principal })
+    end
+
+    def details(sling)
+      return sling.get_node_props(group_url)
+    end
+
+    def remove_member(sling, principal, type)
+      principal_path = "/#{$USERMANAGER_URI}#{type}/#{principal}"
+      return sling.execute_post(sling.url_for("#{group_url}.update.html"),
+              { ":member@Delete" => principal_path })
+    end
+
+    def has_member(sling, principal)
+      detail = self.details(sling)
+      members = detail["members"]
+      if (members == nil)
+        return false
+      end
+      return members.include?(principal)
+    end
+    
+    def remove_member_viewer(sling, principal)
+      return sling.execute_post(sling.url_for("#{group_url}.update.html"),
+              { ":member@Delete" => principal, ":viewer@Delete" => principal })
+    end
+    
+    def add_member_viewer(sling, principal)
+      return sling.execute_post(sling.url_for("#{group_url}.update.html"),
+              { ":member" => principal, ":viewer" => principal })
+    end
+
+    def remove_manager(sling, principal)
+      return sling.execute_post(sling.url_for("#{group_url}.update.html"),
+              { ":manager@Delete" => principal })
+    end
+
+    def remove_viewer(sling, principal)
+      return sling.execute_post(sling.url_for("#{group_url}.update.html"),
+              { ":viewer@Delete" => principal })
+    end
+
+    def remove_members(sling, principals)
+      principal_paths = principals.collect do |principal|
+        if principal.index("g-") == 0
+          type = "group"
+        else
+          type = "user"
+        end
+        "/#{$USERMANAGER_URI}#{type}/#{principal}"
+      end
+      return sling.execute_post(sling.url_for("#{group_url}.update.html"),
+              { ":member@Delete" => principal_paths })
+    end
+
+    def set_joinable(sling, joinable)
+      return sling.execute_post(sling.url_for("#{group_url}.update.html"), "sakai:joinable" => joinable)
+    end
+
+    def members(sling)
+      props = sling.get_node_props(group_url)
+      return props["members"]
+    end
+
+    # Get the home folder of a group.
+    def home_path_for(sling)
+      return "/~#{@name}"
+    end
+
+    def self.url_for(name)
+      return "#{$USERMANAGER_URI}group/#{name}"
+    end
+
+    private
+    def group_url
+      return Group.url_for(@name)
+    end
+  end
+
+
+  class User < Principal
+    attr_accessor :password
+
+    def initialize(username, password=$DEFAULT_PASSWORD)
+      super(username)
+      @password = password
+    end
+
+    def self.admin_user
+      return User.new("admin", "admin")
+    end
+
+    def self.anonymous
+      return AnonymousUser.new
+    end
+
+    def do_request_auth(req)
+      req.basic_auth(@name, @password)
+    end
+
+    def do_curl_auth(c)
+      c.userpwd = "#{@name}:#{@password}"
+    end
+
+    def to_s
+      return "User: #{@name} (pass: #{@password})"
+    end
+
+    def update_properties(sling, props)
+      return sling.execute_post(sling.url_for("#{user_url}.update.html"), props)
+    end
+
+
+	def change_password(sling, newpassword)
+	   return sling.execute_post(sling.url_for("#{user_url}.changePassword.html"), "oldPwd" => @password, "newPwd" => newpassword, "newPwdConfirm" => newpassword)
+	end
+
+
+    # Get the home folder of a group.
+    def home_path_for(sling)
+      return "/~#{@name}"
+    end
+
+
+    def self.url_for(name)
+      return "#{$USERMANAGER_URI}user/#{name}"
+    end
+
+    private
+    def user_url
+      return User.url_for(@name)
+    end
+  end
+
+  class AnonymousUser < User
+
+    def initialize()
+      super("anonymous", "none")
+    end
+
+    def do_curl_auth(c)
+      # do nothing
+    end
+
+    def do_request_auth(r)
+      # do nothing
+    end
+
+  end
+
+  class UserManager
+
+    attr_accessor :log
+
+    def initialize(sling)
+      @sling = sling
+      @date = Time.now().strftime("%Y%m%d%H%M%S%3N")
+      @log = Logger.new(STDOUT)
+      @log.level = Logger::WARN
+    end
+
+    def delete_test_user(id)
+      return delete_user("testuser#{@date}-#{id}")
+    end
+
+    def delete_user(username)
+      result = @sling.execute_post(@sling.url_for("#{User.url_for(username)}.delete.html"),
+                                    { "go" => 1 })
+      if (result.code.to_i > 299)
+        @log.info "Error deleting user"
+        return false
+      end
+      return true
+    end
+
+    def delete_group(groupname)
+      result = @sling.execute_post(@sling.url_for("#{Group.url_for(groupname)}.delete.html"),
+                                    { "go" => 1 })
+      if (result.code.to_i > 299)
+        @log.info "Error deleting group"
+        return false
+      end
+      return true
+    end
+
+    def create_test_user(id)
+      return create_user("testuser#{@date}-#{id}")
+    end
+
+    def create_user(username, firstname = nil, lastname = nil)
+      @log.info "Creating user: #{username}"
+      user = User.new(username)
+      data = { ":name" => user.name,
+              "pwd" => user.password,
+              "pwdConfirm" => user.password
+      }
+      if (!firstname.nil? and !lastname.nil?)
+        data[":sakai:profile-import"] = "{'basic': {'access': 'everybody', 'elements': {'email': {'value': '#{username}@sakai.invalid'}, 'firstName': {'value': '#{firstname}'}, 'lastName': {'value': '#{lastname}'}}}}"
+        # data[":sakai:pages-template"] = "/var/templates/site/defaultuser"
+      end
+      result = @sling.execute_post(@sling.url_for("#{$USER_URI}"), data)
+      if (result.code.to_i > 299)
+        @log.info "Error creating user"
+        return nil
+      end
+      return user
+    end
+    
+    def create_group(groupname, title = nil)
+        @log.info "Creating group: #{groupname}"
+              group = Group.new(groupname)
+      params = { ":name" => group.name }
+      if (title)
+        params['sakai:group-title'] = title
+      end
+      params['sakai:group-description'] = ''
+      params['sakai:group-id'] = groupname
+#      params[':sakai:pages-template'] = '/var/templates/site/defaultgroup'
+      params['sakai:pages-visible'] = 'public'
+      params['sakai:group-joinable'] = 'yes'
+      result = @sling.execute_post(@sling.url_for($GROUP_URI), params)
+      if (result.code.to_i > 299)
+        return nil
+      end
+      return group
+    end
+    
+    def get_user_props(name)
+      return @sling.get_node_props(User.url_for(name))
+    end
+
+    def get_group_props(name)
+      return @sling.get_node_props(Group.url_for(name))
+    end
+
+  end
+
+end