simple_crowd 1.0.5 → 1.1.0

data/lib/simple_crowd/mappers/soap_attributes.rb

@@ -1,13 +1,13 @@
-module SimpleCrowd
-  module Mappers
-    class SoapAttributes
-      def self.produce hash
-        {"int:SOAPAttribute" => hash.inject([]) {|attrs, (key, val)| attrs << {"int:name" => key, "int:values" => {"wsdl:string" => val}}}}
-      end
-      def self.parse attributes
-        soap = attributes[:soap_attribute]
-        (soap && soap.inject({}) {|hash, attr| hash[attr[:name].to_sym] = attr[:values][:string]; hash }) || {}
-      end
-    end
-  end
-end
+module SimpleCrowd
+  module Mappers
+    class SoapAttributes
+      def self.produce hash
+        {"int:SOAPAttribute" => hash.inject([]) {|attrs, (key, val)| attrs << {"int:name" => key, "int:values" => {"wsdl:string" => val}}}}
+      end
+      def self.parse attributes
+        soap = attributes[:soap_attribute]
+        (soap && soap.inject({}) {|hash, attr| hash[attr[:name].to_sym] = attr[:values][:string]; hash }) || {}
+      end
+    end
+  end
+end

data/lib/simple_crowd/mock_client.rb

@@ -9,6 +9,8 @@ module SimpleCrowd
       end
     end
 
+    attr_accessor :app_token
+
     @users = []
     @tokens = []
     @groups = []
@@ -19,7 +21,6 @@ module SimpleCrowd
     def authenticate_application(name = nil, password = nil)
       "MOCKAPPTOKEN"
     end
-    alias_method :app_token, :authenticate_application
 
     def authenticate_user name, password, factors = nil
       (user = find_user_by_name(name)) && user.password && user.password == password ? new_user_token(name) : nil
@@ -112,4 +113,4 @@ module SimpleCrowd
     def groups; self.class.groups; end
 
   end
-end
+end

data/lib/simple_crowd/user.rb

@@ -1,17 +1,17 @@
-module SimpleCrowd
-  class User < CrowdEntity
-
-    # Immutable properties
-    property :id, :immutable => true
-    property :username, :immutable => true, :map_soap => :name
-    property :description, :immutable => true
-    property :active, :immutable => true, :default => true
-    property :directory_id, :immutable => true
-
-    # Assumed available attributes (with soap aliases)
-    property :first_name, :attribute => true, :map_soap => :givenName
-    property :last_name, :attribute => true, :map_soap => :sn
-    property :display_name, :attribute => true, :map_soap => :displayName
-    property :email, :attribute => true, :map_soap => :mail
-  end
-end
+module SimpleCrowd
+  class User < CrowdEntity
+
+    # Immutable properties
+    property :id, :immutable => true
+    property :username, :immutable => true, :map_soap => :name
+    property :description, :immutable => true
+    property :active, :immutable => true, :default => true
+    property :directory_id, :immutable => true
+
+    # Assumed available attributes (with soap aliases)
+    property :first_name, :attribute => true, :map_soap => :givenName
+    property :last_name, :attribute => true, :map_soap => :sn
+    property :display_name, :attribute => true, :map_soap => :displayName
+    property :email, :attribute => true, :map_soap => :mail
+  end
+end

data/lib/simple_crowd/version.rb

@@ -1,3 +1,3 @@
 module SimpleCrowd
-  VERSION = "1.0.5"
+  VERSION = "1.1.0"
 end

data/lib/simple_crowd.rb

@@ -1,51 +1,53 @@
-require 'savon'
-require 'hashie'
-require 'yaml'
-require 'forwardable'
-require 'simple_crowd/crowd_entity'
-require 'simple_crowd/crowd_error'
-require 'simple_crowd/user'
-require 'simple_crowd/group'
-require 'simple_crowd/client'
-require 'simple_crowd/mappers/soap_attributes'
-Dir['simple_crowd/mappers/*.rb'].each {|file| require File.basename(file, File.extname(file)) }
-
-module SimpleCrowd
-  class << self
-    def config &config_block
-      config_block.call(options)
-    end
-
-    def options app_options = {}
-      c = soap_options.merge(default_crowd_options).merge(app_options) and
-          c.merge(:service_url => c[:service_url] + 'services/SecurityServer')
-    end
-    def soap_options
-      @soap_options ||= {
-        :service_ns => "urn:SecurityServer",
-        :service_namespaces => {
-          'xmlns:auth' => 'http://authentication.integration.crowd.atlassian.com',
-          'xmlns:ex' => 'http://exception.integration.crowd.atlassian.com',
-          'xmlns:int' => 'http://soap.integration.crowd.atlassian.com',
-          'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
-          'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance'
-        }
-      }
-    end
-    def default_crowd_options
-      @default_crowd_options ||= {
-        :service_url => "http://localhost:8095/crowd/",
-        :app_name => "crowd",
-        :app_password => ""
-      }
-      defined?(IRB) ? @default_crowd_options.merge(config_file_options) : @default_crowd_options
-    end
-    def config_file_options
-      @config_file_options ||= begin
-        (File.exists?('config/crowd.yml') &&
-            yml = (YAML.load_file('config/crowd.yml')[ENV["RAILS_ENV"] || "development"] || {}) and
-            yml.symbolize_keys!) || {}
-      end
-    end
-  end
-end
+require 'savon'
+require 'hashie'
+require 'yaml'
+require 'forwardable'
+require 'simple_crowd/crowd_entity'
+require 'simple_crowd/crowd_error'
+require 'simple_crowd/user'
+require 'simple_crowd/group'
+require 'simple_crowd/client'
+require 'simple_crowd/mappers/soap_attributes'
+require 'simple_crowd/cache/null_store'
+Dir['simple_crowd/mappers/*.rb'].each {|file| require File.basename(file, File.extname(file)) }
+
+module SimpleCrowd
+  class << self
+    def config &config_block
+      config_block.call(options)
+    end
+
+    def options app_options = {}
+      c = soap_options.merge(default_crowd_options).merge(app_options) and
+          c.merge(:service_url => c[:service_url] + 'services/SecurityServer')
+    end
+    def soap_options
+      @soap_options ||= {
+        :service_ns => "urn:SecurityServer",
+        :service_namespaces => {
+          'xmlns:auth' => 'http://authentication.integration.crowd.atlassian.com',
+          'xmlns:ex' => 'http://exception.integration.crowd.atlassian.com',
+          'xmlns:int' => 'http://soap.integration.crowd.atlassian.com',
+          'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
+          'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance'
+        }
+      }
+    end
+    def default_crowd_options
+      @default_crowd_options ||= {
+        :service_url => "http://localhost:8095/crowd/",
+        :app_name => "crowd",
+        :app_password => "",
+        :cache_prefix => "simple_crowd.",
+      }
+      defined?(IRB) ? @default_crowd_options.merge(config_file_options) : @default_crowd_options
+    end
+    def config_file_options
+      @config_file_options ||= begin
+        (File.exists?('config/crowd.yml') &&
+            yml = (YAML.load_file('config/crowd.yml')[ENV["RAILS_ENV"] || "development"] || {}) and
+            yml.symbolize_keys!) || {}
+      end
+    end
+  end
+end

data/simple_crowd.gemspec

@@ -1,58 +1,27 @@
-$:.push File.expand_path("../lib",__FILE__)
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
 require 'simple_crowd/version'
 
 Gem::Specification.new do |s|
-  s.name = %q{simple_crowd}
-  s.version = SimpleCrowd::VERSION.dup
-  s.platform = Gem::Platform::RUBY
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Paul Strong"]
-  s.description = %q{Simple Atlassian Crowd client using REST and SOAP APIs where needed.
-                         Doesn't do any fancy object mapping, etc.}
-  s.email = %q{paul@thestrongfamily.org}
-  s.files = %w(
-    .gitignore
-    Gemfile
-    README.md
-    Rakefile
-    lib/simple_crowd.rb
-    lib/simple_crowd/client.rb
-    lib/simple_crowd/crowd_entity.rb
-    lib/simple_crowd/crowd_error.rb
-    lib/simple_crowd/group.rb
-    lib/simple_crowd/mappers/soap_attributes.rb
-    lib/simple_crowd/mock_client.rb
-    lib/simple_crowd/user.rb
-    lib/simple_crowd/version.rb
-    simple_crowd.gemspec
-    test/crowd_config.yml.example
-    test/factories.rb
-    test/helper.rb
-    test/test_client.rb
-    test/test_simple_crowd.rb
-    test/test_user.rb
-  )
-  s.test_files = %w(
-    test/crowd_config.yml.example
-    test/factories.rb
-    test/helper.rb
-    test/test_client.rb
-    test/test_simple_crowd.rb
-    test/test_user.rb
-  )
-  s.homepage = %q{http://github.com/thinkwell/simple_crowd}
+  s.name        = %q{simple_crowd}
+  s.version     = SimpleCrowd::VERSION.dup
+  s.authors     = ["Paul Strong"]
+  s.email       = %q{paul@thestrongfamily.org}
+  s.homepage    = %q{http://github.com/thinkwell/simple_crowd}
+  s.summary     = %q{Simple Atlassian Crowd client using REST and SOAP APIs where needed.}
+  s.description = %q{Simple Atlassian Crowd client using REST and SOAP APIs where needed.  Doesn't do any fancy object mapping, etc.}
+
+  s.rubyforge_project = "simple_crowd"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.5.0}
-  s.summary = %q{Simple Atlassian Crowd client using REST and SOAP APIs where needed.}
 
-  s.add_development_dependency(%q<shoulda>, [">= 0"])
-  s.add_development_dependency(%q<fcoury-matchy>, [">= 0"])
-  s.add_development_dependency(%q<factory_girl>, [">= 0"])
-  s.add_development_dependency(%q<forgery>, [">= 0"])
-  s.add_development_dependency(%q<webmock>, [">= 0"])
-  s.add_development_dependency(%q<rr>, [">= 0"])
+  s.add_runtime_dependency(%q<savon>, ["~> 0.9.9"])
+  s.add_runtime_dependency(%q<hashie>, [">= 1.0.0"])
+
+  s.add_development_dependency(%q<bundler>, [">= 1.0.21"])
   s.add_development_dependency(%q<rake>, [">= 0"])
-  s.add_runtime_dependency(%q<savon>, ["= 0.7.9"])
-  s.add_runtime_dependency(%q<hashie>, ["= 1.0.0"])
 end
 

data/test/crowd_config.yml.example

@@ -1,6 +1,6 @@
-# Configure Crowd Test server for unit tests
-# Replace default values with crowd server params
-crowd:
-  service_url: http://www.crowdserver.com:8095/crowd/
-  app_name: crowdapp
-  app_password: testpass
+# Configure Crowd Test server for unit tests
+# Replace default values with crowd server params
+crowd:
+  service_url: http://www.crowdserver.com:8095/crowd/
+  app_name: crowdapp
+  app_password: testpass

data/test/factories.rb

@@ -1,9 +1,11 @@
-Factory.define :user, :class => SimpleCrowd::User do |u|
-  u.first_name 'Test'
-  u.last_name  'User'
-  u.display_name {|a| "#{a.first_name} #{a.last_name}"}
-  u.email {|a| "#{a.first_name}.#{a.last_name}@example.com".downcase }
-  u.sequence(:username) {|n| "test#{n}" }
-  # Clear dirty properties
-  u.after_build { |user| user.dirty_properties.clear }
-end
+FactoryGirl.define do
+  factory :user, :class => SimpleCrowd::User do
+    first_name 'Test'
+    last_name  'User'
+    display_name {|a| "#{a.first_name} #{a.last_name}"}
+    email {|a| "#{a.first_name}.#{a.last_name}@example.com".downcase }
+    sequence(:username) {|n| "test#{n}" }
+    # Clear dirty properties
+    after_build { |user| user.dirty_properties.clear }
+  end
+end

data/test/helper.rb

@@ -1,28 +1,32 @@
-require 'rubygems'
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-
-$CROWD_CONFIG_PATH = File.join(File.dirname(__FILE__), 'crowd_config.yml')
-
-require 'simple_crowd'
-require 'test/unit'
-require 'shoulda'
-require 'matchy'
-require 'webmock/test_unit'
-require 'rr'
-require 'factory_girl'
-require 'forgery'
-
-# Load factories
-require File.dirname(__FILE__) + "/factories"
-
-WebMock.allow_net_connect!
-
-class Test::Unit::TestCase
-  include WebMock
-  include RR::Adapters::TestUnit
-  def setup
-    WebMock.allow_net_connect!
-  end
-end
+require 'rubygems'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+$CROWD_CONFIG_PATH = File.join(File.dirname(__FILE__), 'crowd_config.yml')
+
+require 'simple_crowd'
+require 'test/unit'
+require 'shoulda'
+require 'matchy'
+require 'webmock/test_unit'
+require 'rr'
+require 'factory_girl'
+require 'forgery'
+
+# Load factories
+require File.dirname(__FILE__) + "/factories"
+
+WebMock.allow_net_connect!
+
+class Test::Unit::TestCase
+  include RR::Adapters::TestUnit
+  def setup
+    WebMock.allow_net_connect!
+  end
+end
+
+Savon.configure do |config|
+  config.log = false
+end
+HTTPI.log = false

data/test/test_client.rb

@@ -1,331 +1,329 @@
-require 'helper'
-
-class TestClient < Test::Unit::TestCase
-  CROWD_CONFIG = YAML.load_file($CROWD_CONFIG_PATH)['crowd']
-  context "A Client" do
-    setup do
-      @client = SimpleCrowd::Client.new({:service_url => CROWD_CONFIG['service_url'],
-                                         :app_name => CROWD_CONFIG['app_name'],
-                                         :app_password => CROWD_CONFIG['app_password']})
-      @service_url = @client.options[:service_url]
-      reset_webmock
-    end
-    should "initialize" do
-      @client.should_not be nil
-      assert_instance_of SimpleCrowd::Client, @client
-    end
-    should "get app token" do
-      token = @client.app_token
-      token.should_not be nil
-      token.length.should == 24
-      
-      assert_requested :post, @service_url
-    end
-    should "refresh app token if invalid" do
-      # Get initial valid token
-      token = @client.app_token
-      info = @client.get_cookie_info
-      info.should_not be nil
-      @client.app_token = token + "invalid"
-      @client.app_token.should == token + "invalid"
-      # making the token invalid should cause the client to refresh it
-      # and get the cookie info successfully
-      @client.get_cookie_info.should == info
-      # Validate refreshed token is same as original token
-      @client.app_token.should == token
-      assert_requested :post, @service_url, :times => 5
-    end
-    should "get cookie info" do
-      info = @client.get_cookie_info
-      info.should_not be nil
-      info[:domain].should_not be nil
-      info[:domain].length.should > 0
-      info[:secure].should_not be nil
-      assert_requested :post, @service_url, :times => 2
-    end
-    should "authenticate user" do
-      token = @client.authenticate_user "test", "test"
-      token.should_not be nil
-      token.length.should == 24
-
-      assert_requested :post, @service_url, :times => 2
-    end
-    should "authenticate user with validation factors" do
-      token = @client.authenticate_user "test", "test", {:test_factor => "test1234"}
-      token.should_not be nil
-      token.length.should == 24
-
-      assert_requested :post, @service_url, :times => 2
-    end
-    should "create user token without password" do
-      token = @client.create_user_token "test"
-      token.should_not be nil
-      token.length.should == 24
-
-      assert_requested :post, @service_url, :times => 2
-    end
-    should "return same user token with or without password" do
-      token_with_pass = @client.authenticate_user "test", "test"
-      token_with_pass.should_not be nil
-      token_with_pass.length.should == 24
-      token_without_pass = @client.create_user_token "test"
-      token_without_pass.should_not be nil
-      token_with_pass.length.should == 24
-
-      token_with_pass.should == token_without_pass
-
-      assert_requested :post, @service_url, :times => 3
-    end
-    should "validate user token" do
-      token = @client.authenticate_user "test", "test"
-      valid = @client.is_valid_user_token? token
-      valid.should be true
-      invalid = @client.is_valid_user_token?(token + "void")
-      invalid.should be false
-      assert_requested :post, @service_url, :times => 4
-    end
-    should "validate user token with factors" do
-      token = @client.authenticate_user "test", "test", {"Random-Number" => 6375}
-      @client.is_valid_user_token?(token).should be false
-      @client.is_valid_user_token?(token, {"Random-Number" => 6375}).should be true
-      token2 = @client.authenticate_user "test", "test"
-      @client.is_valid_user_token?(token2, {"Random-Number" => 48289}).should be false
-      assert_requested :post, @service_url, :times => 6
-    end
-    should "invalidate user token (logout)" do
-      token = @client.authenticate_user "test", "test"
-      @client.is_valid_user_token?(token).should be true
-
-      # Invalidate nonexistant token
-      @client.invalidate_user_token(token + "void").should be true
-      @client.is_valid_user_token?(token).should be true
-
-      # Invalidate token
-      @client.invalidate_user_token(token).should be true
-      @client.is_valid_user_token?(token).should be false
-      
-      assert_requested :post, @service_url, :times => 7
-    end
-    should "reset user password" do
-      # Get real app token before mocking reset call
-      @client.app_token
-      WebMock.disable_net_connect!
-
-      response = %Q{<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
-          xmlns:xsd="http://www.w3.org/2001/XMLSchema"
-          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-          <soap:Body><ns1:resetPrincipalCredentialResponse xmlns:ns1="urn:SecurityServer" />
-          </soap:Body></soap:Envelope>
-      }
-      stub_request(:post, @service_url).to_return(:body => response, :status => 200)
-      
-      @client.reset_user_password("test").should be true
-    end
-    should "find all user names" do
-      names = @client.find_all_user_names
-      names.should_not be nil
-      names.is_a?(Array).should be true
-      names.empty?.should be false
-      names.include?("test").should be true
-    end
-    should "find user by name" do
-      user = @client.find_user_by_name "test"
-      user.should_not be nil
-      [:id, :username, :description, :active, :directory_id, :first_name, :last_name, :email].each {|v| user.key?(v).should be true}
-      [:id, :username, :active, :directory_id].each {|v| user[v].should_not be nil}
-      assert_requested :post, @service_url, :times => 2
-    end
-    should "find user by token" do
-      token = @client.authenticate_user "test", "test"
-      user = @client.find_user_by_token token
-      user.should_not be nil
-      user.first_name.should == "Test"
-
-      assert_requested :post, @service_url, :times => 3
-    end
-    should "find username by token" do
-      token = @client.authenticate_user "test", "test"
-      user = @client.find_username_by_token token
-      user.should_not be nil
-      user.length.should > 0
-      user.should == "test"
-
-      assert_requested :post, @service_url, :times => 3
-    end
-    should "find user by email" do
-      user = @client.find_user_by_email "test@testing.com"
-      user.should_not be nil
-      user.first_name.should == "Test"
-      user.last_name.should == "User"
-
-      # partial searches should return nothing
-      user = @client.find_user_by_email "test"
-      user.should be nil
-
-      assert_requested :post, @service_url, :times => 3
-    end
-    should "search for users by email" do
-      users = @client.search_users_by_email "test"
-      users.empty?.should_not be true
-      users.all?{|u| u.email =~ /test/ }.should be true
-
-      assert_requested :post, @service_url, :times => 2
-    end
-    should "search users" do
-      users = @client.search_users({'principal.email' => "test@testing.com"})
-      users.should_not be nil
-      users.empty?.should_not be true
-      users.all?{|u| u.email == "test@testing.com" }.should be true
-
-      users = @client.search_users({'principal.fullname' => "Test"})
-      users.should_not be nil
-      users.empty?.should_not be true
-      users.each{|u| u.display_name.downcase.should =~ /test/ }
-
-      assert_requested :post, @service_url, :times => 3
-    end
-    should "return nil for nonexistant user" do
-      user = @client.find_user_by_name "nonexistant"
-      user.should be nil
-      assert_requested :post, @service_url, :times => 2
-    end
-    should "update user credential" do
-      @client.authenticate_user("test", "test").should_not be nil
-      @client.update_user_credential("test", "testupdate").should be true
-      lambda {@client.authenticate_user("test", "test")}.should raise_error
-      @client.authenticate_user("test", "testupdate").should_not be nil
-      @client.update_user_credential("test", "test").should be true
-    end
-    should "add/remove user" do
-      localuser = Factory.build(:user)
-      user = @client.add_user(localuser, "newuserpass")
-      user.should_not be nil
-      user.username.should == localuser.username
-      user.first_name.should == localuser.first_name
-      user.last_name.should == localuser.last_name
-      @client.authenticate_user(localuser.username, "newuserpass").should_not be nil
-      @client.remove_user(localuser.username).should be true
-      lambda {@client.authenticate_user(localuser.username, "newuserpass")}.should raise_error
-
-      assert_requested :post, @service_url, :times => 5
-    end
-
-    should "update user attribute" do
-      username = "test_update"
-      localuser = Factory.build(:user, :username => username)
-      remoteuser = @client.add_user(localuser, "updatepass")
-      @client.update_user_attribute(username, 'givenName', 'UpdatedFirst').should be true
-      updateduser = @client.find_user_by_name(username)
-      updateduser.last_name.should == localuser.last_name
-      updateduser.first_name.should == 'UpdatedFirst'
-      @client.remove_user "test_update"
-    end
-    should "update user custom attribute" do
-      username = "test_update"
-      localuser = Factory.build(:user, :username => username)
-      remoteuser = @client.add_user(localuser, "updatepass")
-      @client.update_user_attribute(username, 'customAttr', 'customVal').should be true
-      remoteuser = @client.find_user_with_attributes_by_name username
-      remoteuser.last_name.should == localuser.last_name
-
-      remoteuser[:customAttr].should == 'customVal'
-      @client.remove_user "test_update"
-    end
-    should "update user attribute array" do
-      username = "test_update"
-      localuser = Factory.build(:user, :username => username)
-      remoteuser = @client.add_user(localuser, "updatepass")
-      test_array = ["one", "two", "4"]
-      @client.update_user_attribute(username, 'arrayTest', test_array).should be true
-      remoteuser = @client.find_user_with_attributes_by_name username
-      remoteuser.last_name.should == localuser.last_name
-      remoteuser[:arrayTest].sort.should == test_array.sort
-      test_array.delete "two"
-      @client.update_user_attribute(username, 'arrayTest', test_array).should be true
-      remoteuser = @client.find_user_with_attributes_by_name username
-      remoteuser[:arrayTest].sort.should == test_array.sort
-      remoteuser[:arrayTest].include?("two").should be false
-      @client.remove_user "test_update"
-    end
-    should "update user" do
-      username = "test_update"
-      localuser = Factory.build(:user, :username => username)
-      remoteuser = @client.add_user(localuser, "updatepass")
-      remoteuser.should_not be nil
-      remoteuser.username.should == localuser.username
-      remoteuser.first_name.should == localuser.first_name
-      remoteuser.last_name.should == localuser.last_name
-
-      remoteuser.dirty?.should be false
-      # Should be ignored
-      remoteuser.active = false
-      remoteuser.first_name = "UpdatedFirst"
-      remoteuser.last_name = "UpdatedLast"
-      remoteuser.dirty?.should be true
-
-      remoteuser.dirty_attributes.should == [:first_name, :last_name]
-
-      @client.update_user(remoteuser)
-
-      remoteuser = @client.find_user_with_attributes_by_name username
-      remoteuser.first_name.should == "UpdatedFirst"
-      remoteuser.last_name.should == "UpdatedLast"
-      remoteuser.email.should == localuser.email
-      @client.remove_user "test_update"
-    end
-    should "check if cache enabled" do
-      enabled = @client.is_cache_enabled?
-      is_true = enabled.class == TrueClass
-      is_false = enabled.class == FalseClass
-      (is_true || is_false).should be true
-    end
-    should "get granted authorities" do
-      granted = @client.get_granted_authorities
-      (granted.nil? || (granted.is_a?(Array) && !granted.empty? && granted[0].is_a?(String))).should be true 
-
-      assert_requested :post, @service_url, :times => 2
-    end
-    should "find group by name" do
-      group = @client.find_group_by_name("Testing")
-      group.should_not be nil
-      assert_requested :post, @service_url, :times => 2
-    end
-    should "find all group names" do
-      names = @client.find_all_group_names
-      names.should_not be nil
-      names.is_a?(Array).should be true
-      names.empty?.should be false
-      names.include?("Testing").should be true
-    end
-    should "add/remove user from group" do
-      @client.add_user_to_group("test", "Testing").should be true
-      @client.is_group_member?("Testing", "test").should be true
-      @client.remove_user_from_group("test", "Testing").should be true
-      @client.is_group_member?("Testing", "test").should be false
-      assert_requested :post, @service_url, :times => 5
-    end
-#    should "add/remove attribute from group" do
-#      @client.add_attribute_to_group("test", "tmpattribute", "Hello World").should be true
-#      @client.remove_attribute_from_group("test", "tmpattribute").should be true
-#    end
-    should "update group" do
-      @client.find_group_by_name("Testing").active.should be true
-      @client.update_group("Testing", "Test Description", false).should be true
-      updated_group = @client.find_group_by_name("Testing")
-      updated_group.active.should be false
-      updated_group.description.should == "Test Description"
-      @client.update_group("Testing", "", true).should be true
-    end
-    should "check if user is group member" do
-      @client.add_user_to_group("test", "Testing").should be true
-      @client.is_group_member?("Testing", "test").should be true
-      @client.is_group_member?("nonexistantgroup", "test").should be false
-      assert_requested :post, @service_url, :times => 4
-    end
-    should "accept cached app token" do
-      @client.app_token = "cachedtoken"
-      @client.app_token.should == "cachedtoken"
-      assert_not_requested :post, @service_url
-    end
-  end
-end
+require 'helper'
+
+class TestClient < Test::Unit::TestCase
+  CROWD_CONFIG = YAML.load_file($CROWD_CONFIG_PATH)['crowd']
+  context "A Client" do
+    setup do
+      @client = SimpleCrowd::Client.new({:service_url => CROWD_CONFIG['service_url'],
+                                         :app_name => CROWD_CONFIG['app_name'],
+                                         :app_password => CROWD_CONFIG['app_password']})
+      @service_url = @client.options[:service_url]
+      WebMock.reset!
+    end
+    should "initialize" do
+      @client.should_not be nil
+      assert_instance_of SimpleCrowd::Client, @client
+    end
+    should "get app token" do
+      @client.app_token.should be nil
+      @client.get_cookie_info
+      token = @client.app_token
+      token.should_not be nil
+      token.length.should == 24
+
+      assert_requested :post, @service_url, :times => 2
+    end
+    should "refresh app token if invalid" do
+      @client.app_token = "invalid"
+      @client.app_token.should == "invalid"
+      # making the token invalid should cause the client to refresh it
+      # and get the cookie info successfully
+      @client.get_cookie_info
+      # Validate refreshed token is same as original token
+      @client.app_token.should_not == "invalid"
+      assert_requested :post, @service_url, :times => 3
+    end
+    should "get cookie info" do
+      info = @client.get_cookie_info
+      info.should_not be nil
+      info[:domain].should_not be nil
+      info[:domain].length.should > 0
+      info[:secure].should_not be nil
+      assert_requested :post, @service_url, :times => 2
+    end
+    should "authenticate user" do
+      token = @client.authenticate_user "test", "test"
+      token.should_not be nil
+      token.length.should == 24
+
+      assert_requested :post, @service_url, :times => 2
+    end
+    should "authenticate user with validation factors" do
+      token = @client.authenticate_user "test", "test", {:test_factor => "test1234"}
+      token.should_not be nil
+      token.length.should == 24
+
+      assert_requested :post, @service_url, :times => 2
+    end
+    should "create user token without password" do
+      token = @client.create_user_token "test"
+      token.should_not be nil
+      token.length.should == 24
+
+      assert_requested :post, @service_url, :times => 2
+    end
+    should "return same user token with or without password" do
+      token_with_pass = @client.authenticate_user "test", "test"
+      token_with_pass.should_not be nil
+      token_with_pass.length.should == 24
+      token_without_pass = @client.create_user_token "test"
+      token_without_pass.should_not be nil
+      token_with_pass.length.should == 24
+
+      token_with_pass.should == token_without_pass
+
+      assert_requested :post, @service_url, :times => 3
+    end
+    should "validate user token" do
+      token = @client.authenticate_user "test", "test"
+      valid = @client.is_valid_user_token? token
+      valid.should be true
+      invalid = @client.is_valid_user_token?(token + "void")
+      invalid.should be false
+      assert_requested :post, @service_url, :times => 4
+    end
+    should "validate user token with factors" do
+      token = @client.authenticate_user "test", "test", {"Random-Number" => 6375}
+      @client.is_valid_user_token?(token).should be false
+      @client.is_valid_user_token?(token, {"Random-Number" => 6375}).should be true
+      token2 = @client.authenticate_user "test", "test"
+      @client.is_valid_user_token?(token2, {"Random-Number" => 48289}).should be false
+      assert_requested :post, @service_url, :times => 6
+    end
+    should "invalidate user token (logout)" do
+      token = @client.authenticate_user "test", "test"
+      @client.is_valid_user_token?(token).should be true
+
+      # Invalidate nonexistant token
+      @client.invalidate_user_token(token + "void").should be true
+      @client.is_valid_user_token?(token).should be true
+
+      # Invalidate token
+      @client.invalidate_user_token(token).should be true
+      @client.is_valid_user_token?(token).should be false
+
+      assert_requested :post, @service_url, :times => 7
+    end
+    should "reset user password" do
+      # Get real app token before mocking reset call
+      @client.app_token = @client.authenticate_application
+      WebMock.disable_net_connect!
+
+      response = %Q{<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
+          xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+          <soap:Body><ns1:resetPrincipalCredentialResponse xmlns:ns1="urn:SecurityServer" />
+          </soap:Body></soap:Envelope>
+      }
+      stub_request(:post, @service_url).to_return(:body => response, :status => 200)
+
+      @client.reset_user_password("test").should be true
+    end
+    should "find all user names" do
+      names = @client.find_all_user_names
+      names.should_not be nil
+      names.is_a?(Array).should be true
+      names.empty?.should be false
+      names.include?("test").should be true
+    end
+    should "find user by name" do
+      user = @client.find_user_by_name "test"
+      user.should_not be nil
+      [:id, :username, :description, :active, :directory_id, :first_name, :last_name, :email].each {|v| user.key?(v).should be true}
+      [:id, :username, :active, :directory_id].each {|v| user[v].should_not be nil}
+      assert_requested :post, @service_url, :times => 2
+    end
+    should "find user by token" do
+      token = @client.authenticate_user "test", "test"
+      user = @client.find_user_by_token token
+      user.should_not be nil
+      user.first_name.should == "Test"
+
+      assert_requested :post, @service_url, :times => 3
+    end
+    should "find username by token" do
+      token = @client.authenticate_user "test", "test"
+      user = @client.find_username_by_token token
+      user.should_not be nil
+      user.length.should > 0
+      user.should == "test"
+
+      assert_requested :post, @service_url, :times => 3
+    end
+    should "find user by email" do
+      user = @client.find_user_by_email "test@testing.com"
+      user.should_not be nil
+      user.first_name.should == "Test"
+      user.last_name.should == "User"
+
+      # partial searches should return nothing
+      user = @client.find_user_by_email "test"
+      user.should be nil
+
+      assert_requested :post, @service_url, :times => 3
+    end
+    should "search for users by email" do
+      users = @client.search_users_by_email "test"
+      users.empty?.should_not be true
+      users.all?{|u| u.email =~ /test/ }.should be true
+
+      assert_requested :post, @service_url, :times => 2
+    end
+    should "search users" do
+      users = @client.search_users({'principal.email' => "test@testing.com"})
+      users.should_not be nil
+      users.empty?.should_not be true
+      users.all?{|u| u.email == "test@testing.com" }.should be true
+
+      users = @client.search_users({'principal.fullname' => "Test"})
+      users.should_not be nil
+      users.empty?.should_not be true
+      users.each{|u| u.display_name.downcase.should =~ /test/ }
+
+      assert_requested :post, @service_url, :times => 3
+    end
+    should "return nil for nonexistant user" do
+      user = @client.find_user_by_name "nonexistant"
+      user.should be nil
+      assert_requested :post, @service_url, :times => 2
+    end
+    should "update user credential" do
+      @client.authenticate_user("test", "test").should_not be nil
+      @client.update_user_credential("test", "testupdate").should be true
+      lambda {@client.authenticate_user("test", "test")}.should raise_error
+      @client.authenticate_user("test", "testupdate").should_not be nil
+      @client.update_user_credential("test", "test").should be true
+    end
+    should "add/remove user" do
+      localuser = FactoryGirl.build(:user)
+      user = @client.add_user(localuser, "newuserpass")
+      user.should_not be nil
+      user.username.should == localuser.username
+      user.first_name.should == localuser.first_name
+      user.last_name.should == localuser.last_name
+      @client.authenticate_user(localuser.username, "newuserpass").should_not be nil
+      @client.remove_user(localuser.username).should be true
+      lambda {@client.authenticate_user(localuser.username, "newuserpass")}.should raise_error
+
+      assert_requested :post, @service_url, :times => 5
+    end
+
+    should "update user attribute" do
+      username = "test_update"
+      localuser = FactoryGirl.build(:user, :username => username)
+      remoteuser = @client.add_user(localuser, "updatepass")
+      @client.update_user_attribute(username, 'givenName', 'UpdatedFirst').should be true
+      updateduser = @client.find_user_by_name(username)
+      updateduser.last_name.should == localuser.last_name
+      updateduser.first_name.should == 'UpdatedFirst'
+      @client.remove_user username
+    end
+    should "update user custom attribute" do
+      username = "test_update"
+      localuser = FactoryGirl.build(:user, :username => username)
+      remoteuser = @client.add_user(localuser, "updatepass")
+      @client.update_user_attribute(username, 'customAttr', 'customVal').should be true
+      remoteuser = @client.find_user_with_attributes_by_name username
+      remoteuser.last_name.should == localuser.last_name
+
+      remoteuser[:customAttr].should == 'customVal'
+      @client.remove_user username
+    end
+    should "update user attribute array" do
+      username = "test_update"
+      localuser = FactoryGirl.build(:user, :username => username)
+      remoteuser = @client.add_user(localuser, "updatepass")
+      test_array = ["one", "two", "4"]
+      @client.update_user_attribute(username, 'arrayTest', test_array).should be true
+      remoteuser = @client.find_user_with_attributes_by_name username
+      remoteuser.last_name.should == localuser.last_name
+      remoteuser[:arrayTest].sort.should == test_array.sort
+      test_array.delete "two"
+      @client.update_user_attribute(username, 'arrayTest', test_array).should be true
+      remoteuser = @client.find_user_with_attributes_by_name username
+      remoteuser[:arrayTest].sort.should == test_array.sort
+      remoteuser[:arrayTest].include?("two").should be false
+      @client.remove_user username
+    end
+    should "update user" do
+      username = "test_update"
+      localuser = FactoryGirl.build(:user, :username => username)
+      remoteuser = @client.add_user(localuser, "updatepass")
+      remoteuser.should_not be nil
+      remoteuser.username.should == localuser.username
+      remoteuser.first_name.should == localuser.first_name
+      remoteuser.last_name.should == localuser.last_name
+
+      remoteuser.dirty?.should be false
+      # Should be ignored
+      remoteuser.active = false
+      remoteuser.first_name = "UpdatedFirst"
+      remoteuser.last_name = "UpdatedLast"
+      remoteuser.dirty?.should be true
+
+      remoteuser.dirty_attributes.should == [:first_name, :last_name]
+
+      @client.update_user(remoteuser)
+
+      remoteuser = @client.find_user_with_attributes_by_name username
+      remoteuser.first_name.should == "UpdatedFirst"
+      remoteuser.last_name.should == "UpdatedLast"
+      remoteuser.email.should == localuser.email
+      @client.remove_user username
+    end
+    should "check if cache enabled" do
+      enabled = @client.is_cache_enabled?
+      is_true = enabled.class == TrueClass
+      is_false = enabled.class == FalseClass
+      (is_true || is_false).should be true
+    end
+    should "get granted authorities" do
+      granted = @client.get_granted_authorities
+      (granted.nil? || (granted.is_a?(Array) && !granted.empty? && granted[0].is_a?(String))).should be true 
+
+      assert_requested :post, @service_url, :times => 2
+    end
+    should "find group by name" do
+      group = @client.find_group_by_name("Testing")
+      group.should_not be nil
+      assert_requested :post, @service_url, :times => 2
+    end
+    should "find all group names" do
+      names = @client.find_all_group_names
+      names.should_not be nil
+      names.is_a?(Array).should be true
+      names.empty?.should be false
+      names.include?("Testing").should be true
+    end
+    should "add/remove user from group" do
+      @client.add_user_to_group("test", "Testing").should be true
+      @client.is_group_member?("Testing", "test").should be true
+      @client.remove_user_from_group("test", "Testing").should be true
+      @client.is_group_member?("Testing", "test").should be false
+      assert_requested :post, @service_url, :times => 5
+    end
+#    should "add/remove attribute from group" do
+#      @client.add_attribute_to_group("test", "tmpattribute", "Hello World").should be true
+#      @client.remove_attribute_from_group("test", "tmpattribute").should be true
+#    end
+    should "update group" do
+      @client.find_group_by_name("Testing").active.should be true
+      @client.update_group("Testing", "Test Description", false).should be true
+      updated_group = @client.find_group_by_name("Testing")
+      updated_group.active.should be false
+      updated_group.description.should == "Test Description"
+      @client.update_group("Testing", "", true).should be true
+    end
+    should "check if user is group member" do
+      @client.add_user_to_group("test", "Testing").should be true
+      @client.is_group_member?("Testing", "test").should be true
+      @client.is_group_member?("nonexistantgroup", "test").should be false
+      assert_requested :post, @service_url, :times => 4
+    end
+    should "accept cached app token" do
+      @client.app_token = "cachedtoken"
+      @client.app_token.should == "cachedtoken"
+      assert_not_requested :post, @service_url
+    end
+  end
+end