Software Público Brasileiro

# encoding: UTF-8
require_relative "../test_helper"

class EnterpriseTest < ActiveSupport::TestCase
  fixtures :profiles, :environments, :users

  def setup
    super
    Environment.default.enable('products_for_enterprises')
    @product_category = fast_create(ProductCategory, :name => 'Products')
  end

  def test_identifier_validation
    p = Enterprise.new
    p.valid?
    assert p.errors[:identifier.to_s].present?

    p.identifier = 'with space'
    p.valid?
    assert p.errors[:identifier.to_s].present?

    p.identifier = 'áéíóú'
    p.valid?
    assert p.errors[:identifier.to_s].present?

    p.identifier = 'rightformat2007'
    p.valid?
    refute  p.errors[:identifier.to_s].present?

    p.identifier = 'rightformat'
    p.valid?
    refute  p.errors[:identifier.to_s].present?

    p.identifier = 'right_format'
    p.valid?
    refute  p.errors[:identifier.to_s].present?
  end

  def test_has_domains
    p = Enterprise.new
    assert_kind_of Array, p.domains
  end

  def test_belongs_to_environment_and_has_default
    assert_equal Environment.default, create(Enterprise, :name => 'my test environment', :identifier => 'mytestenvironment').environment
  end

  def test_cannot_rename
    p1 = profiles(:johndoe)
    assert_raise ArgumentError do
      p1.identifier = 'bli'
    end
  end

  should 'have fans' do
    p = fast_create(Person)
    e = fast_create(Enterprise)

    p.favorite_enterprises << e

    assert_includes Enterprise.find(e.id).fans, p
  end

  should 'remove products when removing enterprise' do
    e = fast_create(Enterprise, :name => "My enterprise", :identifier => 'myenterprise')
    create(Product, :enterprise => e, :name => 'One product', :product_category => @product_category)
    create(Product, :enterprise => e, :name => 'Another product', :product_category => @product_category)

    assert_difference 'Product.count', -2 do
      e.destroy
    end
  end

  should 'create a default set of articles' do
    blog = build(Blog)
    Enterprise.any_instance.expects(:default_set_of_articles).returns([blog])
    enterprise = create(Enterprise, :name => 'my test enterprise', :identifier => 'myenterprise')

    assert_kind_of Blog, enterprise.articles.find_by_path(blog.path)
    assert_kind_of RssFeed, enterprise.articles.find_by_path(blog.feed.path)
  end

  should 'create default set of blocks' do
    e = create(Enterprise, :name => 'my new community', :identifier => 'mynewcommunity')

    refute e.boxes[0].blocks.empty?, 'enterprise must have blocks in area 1'
    refute e.boxes[1].blocks.empty?, 'enterprise must have blocks in area 2'
    refute e.boxes[2].blocks.empty?, 'enterprise must have blocks in area 3'
  end

  should 'allow to add new members if has no members' do
    enterprise = fast_create(Enterprise)

    person = fast_create(Person)
    enterprise.add_member(person)

    assert person.is_member_of?(enterprise)
  end

  should 'not allow to add new members' do
    enterprise = fast_create(Enterprise)
    member = fast_create(Person)
    enterprise.add_member(member)
    enterprise.reload

    person = fast_create(Person)
    enterprise.stubs(:notification_emails).returns(['sample@example.org'])
    enterprise.add_member(person)

    assert_equal false, person.is_member_of?(enterprise)
  end

  should 'allow to remove members' do
    c = fast_create(Enterprise, :name => 'my other test profile', :identifier => 'myothertestprofile')
    c.expects(:closed?).returns(false)
    p = create_user('myothertestuser').person

    c.add_member(p)
    assert_includes c.members, p
    c.remove_member(p)
    c.reload
    assert_not_includes c.members, p
  end

  should 'have foudation_year' do
    ent = fast_create(Enterprise, :name => 'test enteprise', :identifier => 'test_ent')

    assert_respond_to ent, 'foundation_year'
    assert_respond_to ent, 'foundation_year='
  end

  should 'have cnpj' do
    ent = fast_create(Enterprise)

    assert_respond_to ent, 'cnpj'
    assert_respond_to ent, 'cnpj='
  end

  should 'block' do
    ent = fast_create(Enterprise, :name => 'test enteprise', :identifier => 'test_ent')
    ent.block
    assert Enterprise.find(ent.id).blocked?
  end

  should 'unblock' do
    ent = fast_create(Enterprise, :name => 'test enteprise', :identifier => 'test_ent')
    ent.data[:blocked] = true
    ent.save
    ent.unblock
    refute Enterprise.find(ent.id).blocked?
  end

  should 'enable and make user admin' do
    ent = fast_create(Enterprise, :name => 'test enteprise', :identifier => 'test_ent', :enabled => false)
    p = create_user('test_user').person

    assert ent.enable(p)
    ent.reload
    assert ent.enabled
    assert_includes ent.members, p
  end

  should 'replace template if environment allows' do
    template = fast_create(Enterprise, :name => 'template enteprise', :identifier => 'template_enterprise', :enabled => false, :is_template => true)
    template.boxes.destroy_all
    template.boxes << Box.new
    template.boxes[0].blocks << Block.new
    template.save!

    e = Environment.default
    e.replace_enterprise_template_when_enable = true
    e.enterprise_default_template = template
    e.save!

    ent = fast_create(Enterprise, :name => 'test enteprise', :identifier => 'test_ent', :enabled => false)

    p = create_user('test_user').person
    ent.enable(p)
    ent.reload
    assert_equal 1, ent.boxes.size
    assert_equal 1, ent.boxes[0].blocks.size
  end

  should 'not replace template if environment doesnt allow' do
    inactive_template = fast_create(Enterprise, :name => 'inactive enteprise template', :identifier => 'inactive_enterprise_template', :is_template => true)
    inactive_template.boxes.destroy_all
    inactive_template.boxes << Box.new
    inactive_template.save!

    active_template = create(Enterprise, :name => 'enteprise template', :identifier => 'enterprise_template')
    assert_equal 4, active_template.boxes.size

    e = Environment.default
    e.inactive_enterprise_template = inactive_template
    e.enterprise_default_template = active_template
    e.save!

    ent = create(Enterprise, :name => 'test enteprise', :identifier => 'test_ent', :enabled => false)

    p = create_user('test_user').person
    ent.enable(p)
    ent.reload
    assert_equal 1, ent.boxes.size
  end

  should 'create EnterpriseActivation task when creating with enabled = false' do
    EnterpriseActivation.delete_all
    ent = create(Enterprise, :name => 'test enteprise', :identifier => 'test_ent', :enabled => false)
    assert_equal [ent], EnterpriseActivation.find(:all).map(&:enterprise)
  end

  should 'create EnterpriseActivation with 7-characters codes' do
    EnterpriseActivation.delete_all
    create(Enterprise, :name => 'test enteprise', :identifier => 'test_ent', :enabled => false)
    assert_equal 7, EnterpriseActivation.find(:first).code.size
  end

  should 'not create activation task when enabled = true' do
    assert_no_difference 'EnterpriseActivation.count' do
      fast_create(Enterprise, :name => 'test enteprise', :identifier => 'test_ent', :enabled => true)
    end
  end

  should 'be able to enable even if there are mandatory fields blank' do
    # enterprise is created, waiting for being enabled
    environment = fast_create(Environment, :name => 'my test environment')
    enterprise = fast_create(Enterprise, :name => 'test enterprise', :identifier => 'test_ent', :enabled => false, :environment_id => environment.id)

    # administrator decides now that the 'city' field is mandatory
    environment.custom_enterprise_fields = { 'city' => { 'active' => 'true', 'required' => 'true' } }
    environment.save!
    assert_equal ['city'], environment.required_enterprise_fields

    # then we try to enable the enterprise with a required field is blank
    enterprise = Enterprise.find(enterprise.id)
    person = profiles(:ze)
    assert enterprise.enable(person)
  end

  should 'list product categories' do
    subcategory = fast_create(ProductCategory, :name => 'Products subcategory', :parent_id => @product_category.id)
    ent = fast_create(Enterprise, :name => 'test ent', :identifier => 'test_ent')
    p = create(Product, :name => 'test prod', :product_category => subcategory, :enterprise => ent)

    assert_equivalent [subcategory], ent.product_categories
  end

  should 'not create a products block for enterprise if environment do not let' do
    env = Environment.default
    env.disable('products_for_enterprises')
    ent = fast_create(Enterprise, :name => 'test ent', :identifier => 'test_ent')
    assert_not_includes ent.blocks.map(&:class), ProductsBlock
  end

  should 'have a enterprise template' do
    template = fast_create(Enterprise, :is_template => true)
    p = fast_create(Enterprise, :name => 'test_com', :identifier => 'test_com', :template_id => template.id)
    assert_equal template, p.template
  end

  should 'have a default enterprise template' do
    env = create(Environment, :name => 'test env')
    p = fast_create(Enterprise, :name => 'test_com', :identifier => 'test_com', :environment_id => env.id)
    assert_kind_of Enterprise, p.template
  end

  should 'have inactive_template even when there is a template set' do
    another_template = fast_create(Enterprise, :is_template => true)
    inactive_template = fast_create(Enterprise, :name => 'inactive enteprise template', :identifier => 'inactive_enterprise_template', :is_template => true)

    e = Environment.default
    e.enable('enterprises_are_disabled_when_created')
    e.inactive_enterprise_template = inactive_template
    e.save!

    ent = create(Enterprise, :name => 'test enteprise', :identifier => 'test_ent', :template => another_template, :environment => e)
    assert_equal inactive_template, ent.template
  end

  should 'contact us enabled by default' do
    e = fast_create(Enterprise, :name => 'test_com', :identifier => 'test_com', :environment_id => Environment.default.id)
    assert e.enable_contact_us
  end

  should 'return active_enterprise_fields' do
    e = Environment.default
    e.expects(:active_enterprise_fields).returns(['contact_phone', 'contact_email']).at_least_once
    ent = build(Enterprise, :environment => e)

    assert_equal e.active_enterprise_fields, ent.active_fields
  end

  should 'return required_enterprise_fields' do
    e = Environment.default
    e.expects(:required_enterprise_fields).returns(['contact_phone', 'contact_email']).at_least_once
    enterprise = build(Enterprise, :environment => e)

    assert_equal e.required_enterprise_fields, enterprise.required_fields
  end

  should 'require fields if enterprise needs' do
    e = Environment.default
    e.expects(:required_enterprise_fields).returns(['contact_phone']).at_least_once
    enterprise = build(Enterprise, :environment => e)
    refute  enterprise.valid?
    assert enterprise.errors[:contact_phone.to_s].present?

    enterprise.contact_phone = '99999'
    enterprise.valid?
    refute  enterprise.errors[:contact_phone.to_s].present?
  end

  should 'not require fields if enterprise is a template' do
    e = Environment.default
    e.expects(:required_enterprise_fields).returns(['contact_phone']).at_least_once
    enterprise = build(Enterprise, :environment => e)
    refute  enterprise.valid?
    assert enterprise.errors[:contact_phone.to_s].present?

    enterprise.is_template = true
    enterprise.valid?
    refute  enterprise.errors[:contact_phone.to_s].present?
  end

  should 'enable contact' do
    enterprise = build(Enterprise, :enable_contact_us => false)
    refute enterprise.enable_contact?
    enterprise.enable_contact_us = true
    assert enterprise.enable_contact?
  end

  should 'save organization_website with http' do
    p = build(Enterprise, :name => 'test_ent', :identifier => 'test_ent')
    p.organization_website = 'website.without.http'
    p.save!
    assert_equal 'http://website.without.http', p.organization_website
  end

  should 'save not add http to empty organization_website' do
    p = build(Enterprise, :name => 'test_ent', :identifier => 'test_ent')
    p.organization_website = ''
    p.save!
    assert_equal '', p.organization_website
  end

  should 'save organization_website as typed if has http' do
    p = build(Enterprise, :name => 'test_ent', :identifier => 'test_ent')
    p.organization_website = 'http://website.with.http'
    p.save
    assert_equal 'http://website.with.http', p.organization_website
  end

  should 'be created disabled if feature enterprises_are_disabled_when_created is enabled' do
    e = Environment.default
    e.enable('enterprises_are_disabled_when_created')
    e.save!

    ent = create(Enterprise, :name => 'test enteprise', :identifier => 'test_ent')
    assert_equal false, Enterprise['test_ent'].enabled?
  end

  should 'enterprise is validated according to feature enterprises_are_validated_when_created' do
    e = Environment.default

    e.enable('enterprises_are_validated_when_created')
    e.save
    enterprise = create(Enterprise, :name => 'test enteprise', :identifier => 'test_ent1')
    assert enterprise.validated

    e.disable('enterprises_are_validated_when_created')
    e.save
    enterprise = create(Enterprise, :name => 'test enteprise', :identifier => 'test_ent2')
    refute enterprise.validated
  end

  should 'have inactive_template when creating enterprise and feature is enabled' do
    inactive_template = fast_create(Enterprise, :name => 'inactive enteprise template', :identifier => 'inactive_enterprise_template', :is_template => true)
    inactive_template.boxes.destroy_all
    inactive_template.boxes << Box.new
    inactive_template.save!

    e = Environment.default
    e.enable('enterprises_are_disabled_when_created')
    e.inactive_enterprise_template = inactive_template
    e.save!

    ent = create(Enterprise, :name => 'test enteprise', :identifier => 'test_ent')
    assert_equal 1, ent.boxes.size
  end

  should 'have active_template when creating enterprise and feature is disabled' do
    inactive_template = fast_create(Enterprise, :name => 'inactive enteprise template', :identifier => 'inactive_enterprise_template', :is_template => true)
    inactive_template.boxes.destroy_all
    inactive_template.boxes << Box.new
    inactive_template.save!

    e = Environment.default
    e.disable('enterprises_are_disabled_when_created')
    e.inactive_enterprise_template = inactive_template
    e.save!

    ent = create(Enterprise, :name => 'test enteprise', :identifier => 'test_ent')
    assert_equal 4, ent.boxes.size
  end

  should 'collect the highlighted products with image' do
    env = Environment.default
    e1 = fast_create(Enterprise)
    p1 = create(Product, :name => 'test_prod1', :product_category_id => @product_category.id, :enterprise => e1)
    products = []
    3.times {|n|
      products.push(create(Product, :name => "product #{n}", :profile_id => e1.id,
        :highlighted => true, :product_category_id => @product_category.id,
        :image_builder => { :uploaded_data => fixture_file_upload('/files/rails.png', 'image/png') }
      ))
    }
    create(Product, :name => "product 4", :profile_id => e1.id, :product_category_id => @product_category.id, :highlighted => true)
    create(Product, :name => "product 5", :profile_id => e1.id, :product_category_id => @product_category.id, :image_builder => {
      :uploaded_data => fixture_file_upload('/files/rails.png', 'image/png')
    })
    assert_equal products, e1.highlighted_products_with_image
  end

  should 'have many inputs through products' do
    enterprise = fast_create(Enterprise)
    product = fast_create(Product, :profile_id => enterprise.id, :product_category_id => @product_category.id)
    product.inputs << build(Input, :product_category => @product_category)
    product.inputs << build(Input, :product_category => @product_category)

    assert_equal product.inputs.sort, enterprise.inputs.sort
  end

  should "the followed_by? be true only to members" do
    e = fast_create(Enterprise)
    e.stubs(:closed?).returns(false)
    p1 = fast_create(Person)
    p2 = fast_create(Person)
    p3 = fast_create(Person)

    refute p1.is_member_of?(e)
    e.add_member(p1)
    assert p1.is_member_of?(e)

    refute p3.is_member_of?(e)
    e.add_member(p3)
    assert p3.is_member_of?(e)

    assert_equal true, e.send(:followed_by?,p1)
    assert_equal true, e.send(:followed_by?,p3)
    assert_equal false, e.send(:followed_by?,p2)
  end

  should 'receive scrap notification' do
    enterprise = fast_create(Enterprise)
    assert_equal false, enterprise.receives_scrap_notification?
  end

  should 'have production cost' do
    e = fast_create(Enterprise)
    assert_respond_to e, :production_costs
  end

  should 'return scraps as activities' do
    person = fast_create(Person)
    enterprise = fast_create(Enterprise)


    activity = ActionTracker::Record.last
    scrap = create(Scrap, defaults_for_scrap(:sender => person, :receiver => enterprise, :content => 'A scrap'))

    assert_equal [scrap], enterprise.activities.map(&:activity)
  end

  should 'return tracked_actions of community as activities' do
    person = fast_create(Person)
    enterprise = fast_create(Enterprise)

    User.current = person.user
    article = create(TinyMceArticle, :profile => enterprise, :name => 'An article about free software')

    assert_equal [article.activity], enterprise.activities.map(&:activity)
  end

  should 'not return tracked_actions of other community as activities' do
    person = fast_create(Person)
    enterprise = fast_create(Enterprise)
    enterprise2 = fast_create(Enterprise)

    User.current = person.user
    article = create(TinyMceArticle, :profile => enterprise2, :name => 'Another article about free software')

    assert_not_includes enterprise.activities.map(&:activity), article.activity
  end

  should 'provide URL to catalog area' do
    environment = create_environment('mycolivre.net')
    enterprise = build(Enterprise, :identifier => 'testprofile', :environment_id => create_environment('mycolivre.net').id)

    assert_equal({:profile => enterprise.identifier, :controller => 'catalog'}, enterprise.catalog_url)
  end

  should 'check if a community admin user is really a community admin' do
    c = fast_create(Enterprise, :name => 'my test profile', :identifier => 'mytestprofile')
    admin = create_user('adminuser').person
    c.add_admin(admin)

    assert c.is_admin?(admin)
  end

  should 'a member user not be a community admin' do
    c = fast_create(Enterprise, :name => 'my test profile', :identifier => 'mytestprofile')
    admin = create_user('adminuser').person
    c.add_admin(admin)

    member = create_user('memberuser').person
    c.add_member(member)
    refute c.is_admin?(member)
  end

  should 'a moderator user not be a community admin' do
    c = fast_create(Enterprise, :name => 'my test profile', :identifier => 'mytestprofile')
    moderator = create_user('moderatoruser').person
    c.add_moderator(moderator)
    refute c.is_admin?(moderator)
  end


end