require_relative 'helper'

class DirectoriesTest < MiniTest::Unit::TestCase
  def setup
    @dirs = MxHero::API::Directories.new(domain, 
                                   username: TEST_API_USER, 
                                   password: TEST_API_PASSWORD, 
                                   verbose: false, api_url: TEST_API_URL)
  end

  def domain
    'test.com'
  end

  def test_directories_from_api
    directories = MxHero::API::Client.new(api_url: TEST_API_URL, username: TEST_API_USER, 
                                          password: TEST_API_PASSWORD).directories(domain)
    assert directories.is_a? MxHero::API::Directories
    assert_equal domain, directories.instance_variable_get(:@domain)
    assert_equal TEST_API_URL, directories.instance_variable_get(:@service_url)
    assert_equal TEST_API_USER, directories.instance_variable_get(:@username)
    assert_equal TEST_API_PASSWORD, directories.instance_variable_get(:@password)
    assert ! directories.instance_variable_get(:@verbose)
  end

  def test_fetch
    VCR.use_cassette('fetch_directory') do
      directory = @dirs.fetch
      assert_equal domain, directory.domain 
      assert_equal 'gapps', directory.type
    end
  end
  
  def test_create
    directory = MxHero::API::Directory.new(domain: 'test.com', type: 'gapps',
                                           user: 'user', password: 'password')
    
    VCR.use_cassette('create_directory') do 
      response = @dirs.create directory
      assert response.success?
      
      # try to create again
      response = @dirs.create directory
      assert ! response.success?  
      assert_equal 'domain.ldap.already.exists', response.error
    end
  end

  def test_update
    VCR.use_cassette('update_directory') do 
      directory = @dirs.fetch
      directory.ssl = true
      directory.base = 'cn'
      directory.type = 'zimbra'
      directory.address = 'zertifikate.telekom.de'
      directory.port = '389'
      directory.user = 'user'
      directory.password = 'password'
      
      assert @dirs.update(directory).success?
      
      updated = @dirs.fetch

      assert_equal directory.ssl, updated.ssl
      assert_equal directory.base, updated.base
      assert_equal directory.type, updated.type
      assert_equal directory.address, updated.address
      assert_equal directory.port, updated.port
      assert_equal directory.user, updated.user
      assert_equal directory.password, updated.password
    end
  end

  def test_delete
    VCR.use_cassette('delete_directory') do 
      deleted = @dirs.delete
      assert deleted.success?
      assert_nil @dirs.fetch

      # try to remove inexistent directory
      deleted = @dirs.delete
      assert ! deleted.success?
      assert_equal 'domain.ldap.not.found', deleted.error
    end
  end

  def test_refresh
    VCR.use_cassette('refresh_directory') do
      refresh_response = @dirs.refresh
      assert refresh_response.success?
    end
  end

  def test_updates_dates
    directory = MxHero::API::Directory.new
    directory.next_update = 1379949740000
    directory.last_update = '1379949740000'
    expected = "2013-09-23T15:22:20+00:00"
    assert_equal expected, directory.next_update.to_s #23-09-2013 12:22 
    assert_equal expected, directory.last_update.to_s #23-09-2013 12:22 
  end

  def test_update_properties
    directory = MxHero::API::Directory.new domain: domain, 
      type: 'gapps', address: nil, port: nil, ssl: false, 
      user: 'test_user', password: 'password', filter: nil,
      base: nil, next_update: 1379949740000, last_update: 1379949740000,
      override: false, dn_authenticate: nil
    changes = {
      type: 'ldap', address: 'ldap.mxhero.com', port: 1234, ssl: true,
      user: 'mxhero_user', password: 'xxx', filter: 'filter',
      base: 'base', next_update: Date.new, last_update: nil, 
      override: true, dn_authenticate: 'dn_autheticate message'
    }
    directory.update_properties changes 
    changes.keys.each { |prop| assert_equal changes[prop], directory.send(prop) }
  end

  def test_initialize_properties
	  directory = MxHero::API::Directory.new domain: domain, 
  		properties: [ {name: 'email', key: 'ldap.email'}, {name: 'name', key: 'user.name'} ]

	  assert_equal({ email: 'ldap.email', name: 'user.name' }, directory.properties)

    directory = MxHero::API::Directory.new domain: domain, 
      properties: { email: 'ldap.email', name: 'user.name' }
    
    assert_equal({ email: 'ldap.email', name: 'user.name' }, directory.properties)
  end

  def test_properties_to_json
    directory = MxHero::API::Directory.new domain: domain, 
      properties: { email: 'ldap.email', name: 'user.name' }
   
    expected = {
      domain: directory.domain, directoryType: directory.type,
      addres: directory.address, port: directory.port, sslFlag: directory.ssl,
      user: directory.user, password: directory.password, filter: directory.filter,
      base: directory.base, nextUpdate: directory.next_update, 
      lastUpdate: directory.last_update, error: directory.error, 
      overrideFlag: directory.override, dnAuthenticate: directory.dn_authenticate, 
      properties: [ { name: 'email', key:'ldap.email' }, { name: 'name', key: 'user.name' } ]
    }
    
    assert_equal expected.to_json, directory.to_json

    directory = MxHero::API::Directory.new domain: domain
    expected[:properties] = []
    assert_equal expected.to_json, directory.to_json
  end

end