require File.dirname(__FILE__) + '/../test_helper'

class GroupTest < Test::Unit::TestCase
  fixtures :groups, :users, :projects

  def setup
    RetroCM.reload
  end

  def test_crud
    o = Group.new(:name => 'Some Group')
    o.permissions = [RetroAM.permission_list.first]
    assert(o.valid?)
    assert(o.save)

    dpl = Group.find(o.id)
    assert_equal(o, dpl)

    dpl.name = 'New Name'
    assert(dpl.save)    
    assert_not_equal(o.name, dpl.name)
    o.reload
    assert_equal(o.name, dpl.name)

    assert(dpl.destroy)
  end
  
  def test_presence_validations
    o = Group.new
    assert(!o.save)
    assert_equal([], o.permissions)
    assert_not_nil(o.errors[:name])
    assert_not_nil(o.errors[:permissions])

    o = Group.default_group
    o.permissions = nil
    assert(o.save)
    assert_equal([], o.permissions)    
  end

  def test_uniqueness_validations
    o1 = Group.new(:name => 'Some Group')
    o1.permissions = [RetroAM.permission_list.first]
    assert(o1.save)

    o2 = Group.new(:name => 'Some Group')
    o2.permissions = [RetroAM.permission_list.last]
    assert(!o2.save)
    assert_not_nil(o2.errors[:name])
  end

  def test_format_validations
    o = Group.new(:name => 'Some Group')
    o.permissions = [RetroAM.permission_list.first]
    assert(o.save)
    
    ['Some  Group', 'Some Group.', 'Some Group$', 'SomeGroup!'].each do |invalid_name|
      o.name = invalid_name
      assert(!o.save)
    end
      
    ['Some Group1', 'Some Group 1', 'Some Group 1 2 3', 'GroupName', '12sdad', 'Oh that'].each do |valid_name|
      o.name = valid_name     
      assert(o.save)
    end
  end
    
  def test_accessors
    pr = projects(:retro)
    assert_not_nil(pr)
    
    o = Group.new(:permissions => ['all'], :projects => [pr])
    assert_equal([], o.permissions)
    assert(!o.access_to_project?(pr))

    o.attributes = {:project_ids => [pr.id]}
    assert(!o.access_to_project?(pr))
    
    o.projects << pr
    assert(o.access_to_project?(pr))

    o.attributes = {:access_to_all_projects => 1}
    assert(!o.access_to_all_projects?)
  
    o.access_to_all_projects = true
    assert(o.access_to_all_projects?)
  end

  def test_protected_accessors
    o = groups(:default)
    assert_nothing_raised { o.protected_attributes = nil }
    
    o.protected_attributes = {
      :permissions => [],
      :project_ids => [],
      :access_to_all_projects => true
    }
    assert_equal([], o.permissions)
    assert_equal([], o.project_ids)
    assert(o.access_to_all_projects?)

    o.protected_attributes = { :access_to_all_projects => '1' }
    assert(o.access_to_all_projects?)

    o.protected_attributes = { :access_to_all_projects => '0' }
    assert(!o.access_to_all_projects?)

    assert(o.save)
  end

  def test_not_possible_to_destroy_default_group
    o = Group.default_group
    assert(!o.destroy)  
  end
  
  def test_if_default_group_can_be_modified
    o = Group.default_group
    assert(o.default?)
    
    o.name = 'Other Name'
    assert(o.save)    
    o.reload    
    assert_equal(o.name, 'Default')    
  end
  
  def test_default_content_creation
    assert(Group.delete_all)
    assert(Group.create(:name => 'Default'))
  end

  def test_projects_and_permissions_associations
    o = Group.new(:name => 'Some Group')
    perm = RetroAM.permission_list.first
    o.permissions = [perm]
    assert(o.save)    
    
    assert(o.permissions.include?(perm))
    assert(o.includes_permission?(perm))
    
    pr = projects(:retro)
    assert_not_nil(pr)
    o.access_to_all_projects = false
    o.projects << pr
    assert(o.save)
    
    assert(o.projects.include?(pr))
    assert(o.access_to_project?(pr))

    assert_equal([pr.name], o.project_names)

    o.projects = []
    o.access_to_all_projects = true
    assert(o.save)
    assert(o.reload)
  
    assert(o.projects.include?(pr))
    assert(o.access_to_project?(pr))
    assert_equal(['All'], o.project_names)
  end
    
  def test_permission_assignment
    valid_permission = RetroAM.permission_list.first
    invalid_permission = (valid_permission.to_s + '_invalid').to_sym
    
    o = Group.new(:name => 'Some Group')
    o.permissions = [valid_permission, invalid_permission]
    assert_equal([valid_permission], o.permissions)

    o.permissions = [valid_permission, valid_permission]
    assert_equal([valid_permission], o.permissions)       
  end
end