sugarcrm_emp 0.10.0

data/test/connection/test_set_document_revision.rb

@@ -0,0 +1,28 @@
+require 'helper'
+
+class TestSetDocumentRevision < ActiveSupport::TestCase
+  context "A SugarCRM.connection" do
+    should "Update a document revision" do
+      file = File.read("test/config_test.yaml")
+      # Create a new document, no file is attached or uploaded at this stage.
+      d = SugarCRM::Document.create(
+        :revision     => 1, 
+        :active_date  => Date.today,
+        :filename     => "config_test.yaml", 
+        :document_name=> "config_test.yaml",
+        :uploadfile   => "config_test.yaml"
+      )
+      # Did we succeed?
+      assert !d.new?
+      # Create a new document revision, attaching the file to the document_revision, and associating the document
+      # revision with parent document
+      assert SugarCRM.connection.set_document_revision(d.id, d.revision + 1, {:file => file, :file_name => "config_test.yaml"})
+      # Delete the document
+      assert d.delete
+      # Remove any document revisions associated with that document
+      SugarCRM::DocumentRevision.find_all_by_document_id(d.id).each do |dr|
+        assert dr.delete
+      end
+    end
+  end
+end

data/test/connection/test_set_entry.rb

@@ -0,0 +1,15 @@
+require 'helper'
+
+class TestSetEntry < ActiveSupport::TestCase
+  context "A SugarCRM.connection" do
+    should "set values on an Bean with #set_entry" do
+      
+      name_value_list = { 
+        "name"        => { "name" => "name",        "value" => "A Test Meeting" },
+        "date_start"  => { "name" => "date_start",  "value" => "2011-11-23 12:03:16" },
+        "description" => { "name" => "description", "value" => "RT @bumblebeenie &quot;It's Childish Gambino, home girl drop it like the Nasdaq&quot; Are you serious bro?" }
+      }
+      meeting = SugarCRM.connection.set_entry("Meetings", name_value_list)
+    end
+  end
+end

data/test/connection/test_set_note_attachment.rb

@@ -0,0 +1,16 @@
+require 'helper'
+
+class TestSetNoteAttachment < ActiveSupport::TestCase
+  context "A SugarCRM.connection" do
+    should "Add an attachment to a Note" do
+      n = SugarCRM::Note.new
+      n.name = "A Test Note"
+      assert n.save
+      file = File.read("test/config_test.yaml")
+      assert SugarCRM.connection.set_note_attachment(n.id, "config_test.yaml", file)
+      attachment = SugarCRM.connection.get_note_attachment(n.id)
+      assert_equal file, Base64.decode64(attachment["file"])
+      assert n.delete
+    end
+  end
+end

data/test/connection/test_set_relationship.rb

@@ -0,0 +1,18 @@
+require 'helper'
+
+class TestSetRelationship < ActiveSupport::TestCase
+  context "A SugarCRM.connection" do
+    should "add and remove a relationship when #set_relationship" do
+      meeting  = SugarCRM::Meeting.new
+      meeting.date_start = DateTime.now
+      meeting.duration_hours = 0.5
+      meeting.name = "Stupid Meeting"
+      assert meeting.save!
+      response = SugarCRM.connection.set_relationship("Users","1","meetings", [meeting.id])
+      assert response["created"] == 1
+      response = SugarCRM.connection.set_relationship("Users","1","meetings", [meeting.id], {:delete => 1})
+      assert response["deleted"] == 1
+      assert meeting.delete
+    end
+  end
+end

data/test/extensions_test/patch.rb

@@ -0,0 +1,9 @@
+SugarCRM::Contact.class_eval do
+  def self.is_extended?
+    true
+  end
+  
+  def is_extended?
+    true
+  end
+end

data/test/helper.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'active_support/test_case'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'sugarcrm'
+
+CONFIG_PATH = File.join(File.dirname(__FILE__),'config.yaml')
+
+class ActiveSupport::TestCase
+  # put your credentials into a YAML file in the test directory
+  # the format should be identical to the config_test.yaml found in the same directory
+  raise "test/config.yaml file not found. See README for instructions on setting up a testing environment" unless File.exists? CONFIG_PATH
+  SugarCRM::Session.from_file(CONFIG_PATH)
+end

data/test/test_association_collection.rb

@@ -0,0 +1,11 @@
+require 'helper'
+
+class TestAssociationCollection < ActiveSupport::TestCase
+  context "A SugarCRM::AssociationCollection instance" do
+    should "create a new instance when #new" do
+      u   = SugarCRM::User.find("seed_sarah_id")
+      ac  = SugarCRM::AssociationCollection.new(u,:email_addresses)
+      assert_instance_of SugarCRM::AssociationCollection, ac
+    end
+  end
+end

data/test/test_associations.rb

@@ -0,0 +1,156 @@
+require 'helper'
+
+class TestAssociations < ActiveSupport::TestCase
+  context "A SugarCRM::Associations class" do
+    should "Return an array of Association objects when self#register(SugarCRM::User.new)" do
+      associations = SugarCRM::Associations.register(SugarCRM::User.new)
+      assert associations.include? "email_addresses"
+      assert associations.proxy_methods.include? "email_addresses"
+    end
+  end
+  
+  context "A SugarCRM::Association class" do
+    should "compute relationship cardinality correctly" do
+      c = SugarCRM::Case.first
+      link_fields_hash = c.associations.classify{|i| i.link_field}
+      # TODO: test one_to_one cardinality by creating custom module with custom relationship
+      # (no "official" one-to-one relationship exists in Sugar out of the box)
+      assert_equal :one_to_many, link_fields_hash['calls'].first.cardinality
+      assert_equal :many_to_one, link_fields_hash['accounts'].first.cardinality
+      assert_equal :many_to_many, link_fields_hash['contacts'].first.cardinality
+    end
+    should "respond to #pretty_print" do
+      a = SugarCRM::Case.first.associations.first
+      assert_respond_to a, :pretty_print
+    end
+  end
+  
+  context "A SugarCRM::Base instance" do
+    should "return an email address when sent #email_addresses" do
+      u = SugarCRM::User.find("seed_sarah_id")
+      assert_instance_of SugarCRM::AssociationCollection, u.email_addresses
+      assert_instance_of SugarCRM::EmailAddress, u.email_addresses.first
+      assert_equal "sarah@example.com", u.email_addresses.first.email_address
+    end
+    
+    should "utilize the association cache" do
+      u = SugarCRM::User.find(1)
+      u.email_addresses
+      assert u.association_cached? :email_addresses
+    end
+    
+    should "permit adding a record to an association collection (such as #meetings << Meeting.new)" do
+      u = SugarCRM::User.find(1)
+      m = SugarCRM::Meeting.new
+      m.date_start = DateTime.now
+      m.duration_hours = 0.5
+      m.name = "Yet Another Stupid Meeting"
+      u.meetings << m
+      assert u.meetings.include?(m)
+      assert_equal [m], u.meetings.added
+      assert u.save!
+      u = SugarCRM::User.find(1)
+      assert u.meetings.include?(m)
+      assert u.meetings.delete(m)
+      assert u.meetings.save!
+      assert !u.meetings.include?(m)
+    end
+    
+    # TODO: Fix created_by_link to only return a single result
+    should "return a user when sent #created_by_link" do
+      a = SugarCRM::Account.first
+      assert_instance_of SugarCRM::User, a.created_by_link.first
+    end
+    
+    should "create relationships with associate!" do
+      a = SugarCRM::Account.first
+      c = SugarCRM::Contact.create(:last_name => 'Doe')
+      
+      nb_contacts = a.contacts.size
+      a.associate!(c)
+      assert_equal nb_contacts + 1, a.contacts.size # test association_cache is updated
+      
+      assert_equal nb_contacts + 1, SugarCRM::Account.first.contacts.size # test relationship is created in Sugar
+      
+      assert c.delete
+    end
+    
+    should "destroy relationships with disassociate!" do
+      a = SugarCRM::Account.first
+      c = SugarCRM::Contact.create(:last_name => 'Doe')
+      
+      a.associate!(c)
+      nb_contacts = a.contacts.size
+      a.disassociate!(c)
+      assert_equal nb_contacts - 1, a.contacts.size # test association_cache is updated
+      
+      assert_equal nb_contacts - 1, SugarCRM::Account.first.contacts.size # test relationship is destroyed in Sugar
+      
+      assert c.delete
+    end
+    
+    should "not destroy a relationship if associate! is called with {:delete => 0}" do
+      a = SugarCRM::Account.first
+      c = SugarCRM::Contact.create(:last_name => 'Doe')
+      
+      a.associate!(c)
+      nb_contacts = a.contacts.size
+      a.associate!(c, {:delete => 0})
+      assert_equal nb_contacts, a.contacts.size
+      
+      assert c.delete
+    end
+    
+    should "update association cache on associate! only if association changes" do
+      a = SugarCRM::Account.first
+      c = SugarCRM::Contact.create(:last_name => 'Doe')
+      
+      nb_contacts = a.contacts.size
+      a.associate!(c)
+      assert_equal nb_contacts + 1, a.contacts.size
+      a.associate!(c)
+      assert_equal nb_contacts + 1, a.contacts.size # should not change: already associated
+      
+      assert c.delete
+    end
+    
+    should "update association cache on << only if association changes" do
+      a = SugarCRM::Account.first
+      c = SugarCRM::Contact.create(:last_name => 'Doe')
+      
+      nb_contacts = a.contacts.size
+      a.contacts  << c
+      assert_equal nb_contacts + 1, a.contacts.size
+      a.contacts  << c
+      assert_equal nb_contacts + 1, a.contacts.size # should not change: already associated
+      
+      assert c.delete
+    end
+    
+    should "update association cache for both sides of the relationship when calling associate!" do
+      a = SugarCRM::Account.first
+      c = SugarCRM::Contact.create(:last_name => 'Doe')
+      
+      nb_contacts = a.contacts.size
+      nb_accounts = c.accounts.size
+      a.associate!(c)
+      assert_equal nb_contacts + 1, a.contacts.size
+      assert_equal nb_accounts + 1, c.accounts.size
+      
+      assert c.delete
+    end
+    
+    should "update association cache for both sides of the relationship when calling <<" do
+      a = SugarCRM::Account.first
+      c = SugarCRM::Contact.create(:last_name => 'Doe')
+      
+      nb_contacts = a.contacts.size
+      nb_accounts = c.accounts.size
+      a.contacts  << c
+      assert_equal nb_contacts + 1, a.contacts.size
+      assert_equal nb_accounts + 1, c.accounts.size
+      
+      assert c.delete
+    end
+  end
+end

data/test/test_connection.rb

@@ -0,0 +1,13 @@
+require 'helper'
+
+class TestConnection < ActiveSupport::TestCase
+  context "A SugarCRM::Connection instance" do
+    should "retrieve the list of available modules" do
+      assert_instance_of Array, SugarCRM.modules
+      assert_instance_of SugarCRM::Module, SugarCRM.modules[0]
+    end
+    should "create sub-classes by module name" do
+      assert SugarCRM.session.namespace_const.const_defined? "User"
+    end
+  end
+end

data/test/test_connection_pool.rb

@@ -0,0 +1,40 @@
+require 'helper'
+
+class TestConnectionPool < ActiveSupport::TestCase
+  context "A SugarCRM::ConnectionPool instance" do
+    should "have a default pool size of 1 if Rails isn't defined" do
+      assert_equal 1, SugarCRM.session.connection_pool.size
+    end
+    
+    should "be able to specify its pool size" do
+      config = SugarCRM.session.config
+      sess = SugarCRM::Session.new(config[:base_url], config[:username], config[:password], {:connection_pool => {:size => 3}})
+      
+      begin
+        assert_equal 3, sess.connection_pool.size
+      ensure
+        sess.disconnect!
+      end
+    end
+    
+    should "be able to specify its timeout on creation" do
+      default_timeout = SugarCRM.session.connection_pool.timeout
+      
+      config = SugarCRM.session.config
+      sess = SugarCRM::Session.new(config[:base_url], config[:username], config[:password], {:connection_pool => {:wait_timeout => default_timeout+1}})
+      
+      begin
+        assert_equal default_timeout+1, sess.connection_pool.timeout
+      ensure
+        sess.disconnect!
+      end
+    end
+    
+    should "be able to specify its timeout after creation" do
+      timeout = SugarCRM.session.connection_pool.timeout
+      SugarCRM.session.connection_pool.timeout += 1
+      
+      assert_equal timeout + 1, SugarCRM.session.connection_pool.timeout
+    end
+  end
+end

data/test/test_finders.rb

@@ -0,0 +1,201 @@
+require 'helper'
+
+class TestFinders < ActiveSupport::TestCase
+  context "A SugarCRM::Base instance" do
+    should "always return an Array when :all" do
+      users = SugarCRM::User.all(:limit => 10)
+      assert_instance_of Array, users
+      users = SugarCRM::User.find(:all, :conditions => {:user_name => "= #{users.first.user_name}"})
+      assert_instance_of Array, users
+      assert_equal 1, users.length
+      users = SugarCRM::User.find(:all, :conditions => {:user_name => '= invalid_user_123'})
+      assert_instance_of Array, users
+      assert users.length == 0
+    end
+    
+    should "support finding first instance with default sort order (for module using date_entered as creation date)" do
+      expected_account = SugarCRM::Account.first({:order_by => 'date_entered'})
+      account = nil
+      assert_nothing_raised do
+        account = SugarCRM::Account.first
+      end
+      assert_equal expected_account.id, account.id
+    end
+    
+    should "support finding first instance with default sort order (for module using date_created as creation date)" do
+      expected_email = SugarCRM::EmailAddress.first({:order_by => 'date_created'})
+      email = nil
+      assert_nothing_raised do
+        email = SugarCRM::EmailAddress.first
+      end
+      assert_equal expected_email.id, email.id
+    end
+    
+    should "support finding first instance (sorted by attribute)" do
+      account = SugarCRM::Account.first({
+        :order_by => 'name'
+      })
+      assert_instance_of SugarCRM::Account, account
+    end
+    
+    should "support finding last instance (sorted by attribute)" do
+      expected_account = SugarCRM::Account.first({:order_by => 'name DESC'})
+      account = SugarCRM::Account.last({:order_by => 'name'})
+      assert_equal expected_account.id, account.id
+      
+      expected_account = SugarCRM::Account.first({:order_by => 'name DESC'})
+      account = SugarCRM::Account.last({:order_by => 'name ASC'})
+      assert_equal expected_account.id, account.id
+      
+      expected_account = SugarCRM::Account.first({:order_by => 'name ASC'})
+      account = SugarCRM::Account.last({:order_by => 'name DESC'})
+      assert_equal expected_account.id, account.id
+    end
+    
+    should "support finding last instance with symbol as :order_by option" do
+      expected_account = SugarCRM::Account.first({:order_by => 'id DESC'})
+      account = SugarCRM::Account.last({:order_by => :id})
+      assert_equal expected_account.id, account.id
+    end
+    
+    should "support finding last instance (last created)" do
+      expected_account = SugarCRM::Account.first({:order_by => 'date_entered DESC'})
+      account = SugarCRM::Account.last
+      assert_equal expected_account.id, account.id
+    end
+    
+    should "support returning only certain fields" do
+      user = SugarCRM::User.first(:fields => [:first_name, :department])
+      assert_instance_of SugarCRM::User, user
+    end
+    
+    should "raise a RuntimeError when searching for last instance with multiple order clauses" do
+      assert_raise(RuntimeError){ SugarCRM::Account.last({:order_by => 'name, id DESC'}) }
+    end
+    
+    should "raise a RuntimeError when searching for last instance if order clause has weird format" do
+      assert_raise(RuntimeError){ SugarCRM::Account.last({:order_by => 'name id DESC'}) }
+      assert_raise(RuntimeError){ SugarCRM::Account.last({:order_by => 'name DESC id'}) }
+    end
+    
+    should "support searching based on conditions" do
+      accounts = SugarCRM::Account.all({
+        :conditions => { :billing_address_postalcode => ["> '70000'", "< '79999'" ] },
+        :limit => 2,
+        :order_by => 'billing_address_postalcode'
+      })
+      assert_instance_of SugarCRM::Account, accounts.first
+    end
+    
+    should "support searching based on SQL operators" do
+      accounts = SugarCRM::Account.all({
+        :conditions => { :name => "LIKE '%Inc%'" }
+      })
+      assert accounts
+      assert_instance_of SugarCRM::Account, accounts.first
+    end
+    
+    should "return an an instance of itself when sent #find(id)" do
+      assert_instance_of SugarCRM::User, SugarCRM::User.find(1)
+    end
+    
+    should "receive a response containing all fields when sent #get_entry" do
+      u = SugarCRM::User.find(1)
+      assert_not_nil u.user_name
+    end
+    
+    should "return an array of records when sent #find([id1, id2, id3])" do
+      users = SugarCRM::User.find(["seed_sarah_id", 1])
+      assert_not_nil users.last.user_name
+    end
+    
+    # test Base#find_by_sql edge case
+    should "return an array of records with small limit and an offset of 0" do
+      accounts = SugarCRM::Account.all(:limit => 3, :offset => 0)
+      assert_equal 3, accounts.size
+    end
+    
+    # test Base#find_by_sql edge case: force slize size to vary up and down
+    should "return an array of records with small offset and a limit greater than 5 but not divisible by 5" do
+      accounts = SugarCRM::Account.all(:limit => 13, :offset => 2)
+      assert_equal 13, accounts.size
+    end
+    
+    # test Base#find_by_sql standard case
+    should "return an array of records with high limit" do
+      accounts = SugarCRM::Account.all(:limit => 12)
+      assert_equal 12, accounts.size
+    end
+    
+    should "accept a block" do
+      # try small limit which will return result on the first result slice (and call yield block only once)
+      count = 0
+      assert_nothing_raised do
+        SugarCRM::Account.all(:limit => 2){|a|
+          count += 1
+        }
+      end
+      assert_equal 2, count
+      
+      # try larger limit which will require multiple result slices to be fetched and yielded individually (yield block called for each result slice)
+      count = 0
+      assert_nothing_raised do
+        SugarCRM::Account.all(:limit => 12){|a|
+          count += 1
+        }
+      end
+      assert_equal 12, count
+    end
+    
+    should "retrieve all records (with no limit option) correctly" do
+      count = 0
+      SugarCRM::Account.all{|a|
+        count += 1
+      }
+      assert_equal SugarCRM::Account.count, count
+    end
+    
+    should "return an array of records when using :order_by, :limit, and :offset options" do
+      accounts = SugarCRM::Account.all(:order_by => 'name', :limit => 3, :offset => 10)
+      accounts_api = SugarCRM.connection.get_entry_list('Accounts', '1=1', :order_by => 'name', :limit => 3, :offset => 10)
+      assert_equal accounts_api, accounts
+    end
+    
+    should "return an array of records working around a SugarCRM bug when :limit > :offset" do
+      accounts = SugarCRM::Account.all(:order_by => 'name', :limit => 10, :offset => 2)
+      assert_equal 10, accounts.size
+    end
+    
+    should "return an array of 1 record with :limit => 1, :offset => 1" do
+      accounts = SugarCRM::Account.all(:order_by => 'name', :limit => 1, :offset => 1)
+      assert_equal 1, accounts.size
+    end
+    
+    should "ignore :offset => 0" do
+      accounts = SugarCRM::Account.all(:order_by => 'name', :limit => 3)
+      accounts_offset = SugarCRM::Account.all(:order_by => 'name', :limit => 3, :offset => 0)
+      assert_equal accounts, accounts_offset
+    end
+    
+    should "compute offsets correctly" do
+      accounts = SugarCRM::Account.all(:order_by => 'name', :limit => 10, :offset => 3)
+      accounts_first_slice = SugarCRM::Account.all(:order_by => 'name', :limit => 5, :offset => 3)
+      accounts_second_slice = SugarCRM::Account.all(:order_by => 'name', :limit => 5, :offset => 8)
+      assert_equal accounts, accounts_first_slice.concat(accounts_second_slice)
+    end
+    
+    should "return an instance of User when sent User#find_by_username" do
+      u = SugarCRM::User.find_by_user_name("sarah")
+      assert_equal "sarah@example.com", u.email_addresses.first.email_address
+    end
+    
+    should "create or retrieve a record when #find_or_create_by_name" do
+      a = SugarCRM::Account.find_or_create_by_name("Really Important Co. Name")
+      assert_instance_of SugarCRM::Account, a
+      assert !a.new?
+      b = SugarCRM::Account.find_or_create_by_name("Really Important Co. Name")
+      assert a == b
+      assert a.delete
+    end
+  end
+end

data/test/test_module.rb

@@ -0,0 +1,51 @@
+require 'helper'
+
+class TestModule < ActiveSupport::TestCase
+  context "A SugarCRM::Module instance" do
+    should "respond to #fields" do
+      assert_respond_to SugarCRM.modules[0], :fields
+    end
+    
+    should "return required fields when #required_fields" do
+      assert SugarCRM::Account._module.required_fields.include? :name
+    end
+    
+    # TODO: Figure out a way to test this.
+    #should "return the custom table name when #custom_table_name" do
+    #  assert_equal "accounts_cstm", SugarCRM::Account._module.custom_table_name
+    #end
+  end
+  
+  context "SugarCRM::Module" do
+    should "find modules" do
+      assert_instance_of SugarCRM::Module, SugarCRM::Module.find("Accounts")
+    end
+    
+    should "(de)register all modules" do
+      assert SugarCRM.modules.size > 0
+      assert SugarCRM.session.namespace_const.const_defined? 'User'
+      
+      SugarCRM::Module.deregister_all(SugarCRM.session)
+      assert SugarCRM.modules.size == 0
+      assert ! (SugarCRM.session.namespace_const.const_defined? 'User')
+      
+      SugarCRM::Module.register_all(SugarCRM.session)
+      assert SugarCRM.modules.size > 0
+      assert SugarCRM.session.namespace_const.const_defined? 'User'
+    end
+  end
+  
+  context "The SugarCRM class" do
+    should "return current user" do
+      current_user = SugarCRM.current_user
+      assert_instance_of SugarCRM::User, current_user
+      assert_equal SugarCRM.config[:username], current_user.user_name
+    end
+    
+    should "implement reload!" do
+      assert_nothing_raised do
+        SugarCRM.reload!
+      end
+    end
+  end
+end

data/test/test_request.rb

@@ -0,0 +1,35 @@
+require 'helper'
+
+class TestRequest < ActiveSupport::TestCase
+  context "A SugarCRM::Request instance" do
+    setup do
+      @url    = "http://localhost/sugarcrm"
+      @method = "get_entry"
+      @json   =  <<-EOF 
+      {
+        "session": "an invalid session",
+        "module_name": "Accounts",
+        "name_value_list": { 
+          "name": { 
+            "name":  "name",        
+            "value": "A Test Meeting" },
+          "date_start": { 
+            "name":  "date_start",  
+            "value": "2011-11-23 12:03:16" },
+          "description": { 
+            "name":  "description", 
+            "value": "&quot;OMG HAI!&quot;" }
+        }
+      }
+      EOF
+      @json.gsub!(/^\s{6}/, '')
+      @request = SugarCRM::Request.new(@url, @method, @json, false)
+    end
+      
+    should "properly escape JSON" do
+      assert_equal "%7B%22hello%22%3A+%22%5C%22OMG+HAI%21%5C%22%22%7D", @request.escape('{"hello": "&quot;OMG HAI!&quot;"}')
+    end
+      
+  end
+end
+

data/test/test_response.rb

@@ -0,0 +1,26 @@
+require 'helper'
+
+class TestResponse < ActiveSupport::TestCase
+  context "A SugarCRM::Response instance" do
+    setup do
+      @json =  {"entry_list"=> [{
+                "name_value_list"=> {
+                  "address_city" => {"name"=>"address_city", "value"=>""},
+                  "receive_notifications" => {"name"=>"receive_notifications", "value"=>"1"},
+                  "is_group" => {"name"=>"is_group", "value"=>"0"},
+                  "pwd_last_changed" => {"name"=>"pwd_last_changed", "value"=>"never"}
+                },
+                "id"=>"1",
+                "module_name"=>"Users"
+              }],
+             "relationship_list"=>[]}
+  
+      @response = SugarCRM::Response.handle(@json, SugarCRM.session)
+    end
+      
+    should "return an instance of a SugarCRM Module" do
+      assert_instance_of SugarCRM::User, @response
+    end
+      
+  end
+end