Merge commit 'refs/merge-requests/259' of git://gitorious.org/noosfero/noosfero …

…into merge-requests/259 Conflicts: app/controllers/admin/environment_design_controller.rb

Merge commit 'refs/merge-requests/259' of git://gitorious.org/noosfero/noosfero …
…into merge-requests/259 Conflicts: app/controllers/admin/environment_design_controller.rb
Rodrigo Souto
2 parents 5ddf76de 2d5abd83
Showing 7 changed files with 1024 additions and 19 deletions Show diff stats
app/controllers/admin/environment_design_controller.rb
app/controllers/box_organizer_controller.rb
app/controllers/my_profile/profile_design_controller.rb
lib/noosfero/plugin.rb
test/functional/environment_design_controller_test.rb
test/functional/profile_design_controller_test.rb
test/unit/plugin_test.rb
@@ -4,6 +4,7 @@ class EnvironmentDesignController &lt; BoxOrganizerController
   def available_blocks
     @available_blocks ||= [ ArticleBlock, LoginBlock, EnvironmentStatisticsBlock, RecentDocumentsBlock, EnterprisesBlock, CommunitiesBlock, PeopleBlock, SellersSearchBlock, LinkListBlock, FeedReaderBlock, SlideshowBlock, HighlightsBlock, FeaturedProductsBlock, CategoriesBlock, RawHTMLBlock, TagsBlock ]
+    @available_blocks += plugins.dispatch(:extra_blocks, :type => Environment)
   end
 end
@@ -68,8 +68,8 @@ class BoxOrganizerController &lt; ApplicationController
         raise ArgumentError.new("Type %s is not allowed. Go away." % type)
       end
     else
-      @center_block_types = Box.acceptable_center_blocks & available_blocks
-      @side_block_types = Box.acceptable_side_blocks & available_blocks
+      @center_block_types = (Box.acceptable_center_blocks & available_blocks) + plugins.dispatch(:extra_blocks, :type => boxes_holder.class, :position => 1)
+      @side_block_types = (Box.acceptable_side_blocks & available_blocks) + plugins.dispatch(:extra_blocks, :type => boxes_holder.class, :position => [2,3])
       @boxes = boxes_holder.boxes
       render :action => 'add_block', :layout => false
     end
@@ -7,17 +7,25 @@ class ProfileDesignController &lt; BoxOrganizerController
   def available_blocks
     blocks = [ ArticleBlock, TagsBlock, RecentDocumentsBlock, ProfileInfoBlock, LinkListBlock, MyNetworkBlock, FeedReaderBlock, ProfileImageBlock, LocationBlock, SlideshowBlock, ProfileSearchBlock, HighlightsBlock ]
+    blocks += plugins.dispatch(:extra_blocks)
+
     # blocks exclusive for organizations
     if profile.has_members?
       blocks << MembersBlock
     end
-    # blocks exclusive to person
+    # blocks exclusive to people
     if profile.person?
       blocks << FriendsBlock
       blocks << FavoriteEnterprisesBlock
       blocks << CommunitiesBlock
       blocks << EnterprisesBlock
+      blocks += plugins.dispatch(:extra_blocks, :type => Person)
+    end
+
+    # blocks exclusive to communities
+    if profile.community?
+      blocks += plugins.dispatch(:extra_blocks, :type => Community)
     end
     # blocks exclusive for enterprises
@@ -26,6 +34,7 @@ class ProfileDesignController &lt; BoxOrganizerController
       blocks << HighlightsBlock
       blocks << FeaturedProductsBlock
       blocks << FansBlock
+      blocks += plugins.dispatch(:extra_blocks, :type => Enterprise)
     end
     # product block exclusive for enterprises in environments that permits it
@@ -33,7 +42,7 @@ class ProfileDesignController &lt; BoxOrganizerController
       blocks << ProductsBlock
     end
-    # block exclusive to profile has blog
+    # block exclusive to profiles that have blog
     if profile.has_blog?
       blocks << BlogArchivesBlock
     end
@@ -97,6 +97,35 @@ class Noosfero::Plugin
     ERB.new(File.read("#{views_path}/#{file_path}")).result(binding)
   end
+  def extra_blocks(params = {})
+    return [] if self.class.extra_blocks.nil?
+    blocks = self.class.extra_blocks.map do |block, options|
+      type = options[:type]
+      type = type.is_a?(Array) ? type : [type].compact
+      type = type.map do |x|
+        x.is_a?(String) ? x.capitalize.constantize : x
+      end
+      raise "This is not a valid type" if !type.empty? && ![Person, Community, Enterprise, Environment].detect{|m| type.include?(m)}
+
+      position = options[:position]
+      position = position.is_a?(Array) ? position : [position].compact
+      position = position.map{|p| p.to_i}
+      raise "This is not a valid position" if !position.empty? && ![1,2,3].detect{|m| position.include?(m)}
+
+      if !type.empty? && (params[:type] != :all)
+        block = type.include?(params[:type]) ? block : nil
+      end
+
+      if !position.empty? && !params[:position].nil?
+        block = position.detect{ |p| [params[:position]].flatten.include?(p)} ? block : nil
+      end
+
+      block
+    end
+    blocks.compact!
+    blocks || []
+  end
+
   # Here the developer may specify the events to which the plugins can
   # register and must return true or false. The default value must be false.
@@ -351,6 +380,60 @@ class Noosfero::Plugin
     nil
   end
+  # -> Adds additional blocks to profiles and environments.
+  # Your plugin must implements a class method called 'extra_blocks'
+  # that returns a hash with the following syntax.
+  #    {
+  #      'block_name' =>
+  #        {
+  #          :type => 'for which holder the block will be available',
+  #          :position => 'where the block could be displayed'
+  #        }
+  #    }
+  #
+  # Where:
+  #
+  #   - block_name: Name of the new block added to the blocks list
+  #   - type: Might have some of the values
+  #      - 'environment' or Environment: If the block is available only for Environment models
+  #      - 'community' or Community: If the block is available only for Community models
+  #      - 'enterprise' or Enterprise: If the block is available only for Enterprise models
+  #      - 'person' or Person: If the block is available only for Person models
+  #      - nil: If no type parameter is passed the block will be available for all types
+  #   - position: Is the layout position of the block. It should be:
+  #      - '1' or 1: Area 1 of layout
+  #      - '2' or 2: Area 2 of layout
+  #      - '3' or 3: Area 3 of layout
+  #      - nil: If no position parameter is passed the block will be available for all positions
+  #
+  #      OBS: Area 1 is where stay the main content of layout. Areas 2 and 3 are the sides of layout.
+  #
+  # examples:
+  #
+  #   def self.extra_blocks(params)
+  #     {
+  #       #Display 'CustomBlock1' only for 'Person' on position '1'
+  #       CustomBlock1 => {:type => 'person', :position => '1' },
+  #
+  #       #Display 'CustomBlock2' only for 'Community' on position '2'
+  #       CustomBlock2 => {:type => Community, :position => '2' },
+  #
+  #       #Display 'CustomBlock3' only for 'Enterprise' on position '3'
+  #       CustomBlock3 => {:type => 'enterprise', :position => 3 },
+  #
+  #       #Display 'CustomBlock2' for 'Environment' and 'Person' on positions '1' and '3'
+  #       CustomBlock4 => {:type => ['environment', Person], :position => ['1','3'] },
+  #
+  #       #Display 'CustomBlock5' for all types and all positions
+  #       CustomBlock5 => {},
+  #     }
+  #   end
+  #
+  #   OBS: The default value is a empty hash.
+  def self.extra_blocks
+    {}
+  end
+
   def method_missing(method, *args, &block)
     # This is a generic hotspot for all controllers on Noosfero.
     # If any plugin wants to define filters to run on any controller, the name of
@@ -12,22 +12,23 @@ class EnvironmentDesignControllerTest &lt; ActionController::TestCase
     @controller = EnvironmentDesignController.new
     @request    = ActionController::TestRequest.new
     @response   = ActionController::TestResponse.new
+    Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([])
   end
   def test_local_files_reference
     assert_local_files_reference
   end
-  
+
   def test_valid_xhtml
     assert_valid_xhtml
   end
-  
+
   should 'indicate only actual blocks as such' do
     assert(@controller.available_blocks.all? {|item| item.new.is_a? Block})
   end
   ALL_BLOCKS.map do |block|
-    define_method "test_should_#{block.to_s}_is_available" do 
+    define_method "test_should_#{block.to_s}_is_available" do
       assert_includes @controller.available_blocks,block
     end
   end
@@ -191,7 +192,7 @@ class EnvironmentDesignControllerTest &lt; ActionController::TestCase
     assert_tag :tag => 'a', :attributes => {:href => '/admin'}, :child => {:tag => 'span', :content => "Back to control panel"}
   end
-  
+
   should 'render add a new block functionality' do
     login_as(create_admin_user(Environment.default))
     get :add_block
@@ -199,4 +200,170 @@ class EnvironmentDesignControllerTest &lt; ActionController::TestCase
     assert_response :success
     assert_template 'add_block'
   end
+
+  should 'a environment block plugin add new blocks for environments' do
+    class CustomBlock1 < Block; end;
+
+    class TestBlockPlugin < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => Environment},
+        }
+      end
+    end
+
+    Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([TestBlockPlugin.new])
+    assert @controller.available_blocks.include?(CustomBlock1)
+  end
+
+  should 'a person, enterprise and community blocks plugins do not add new blocks for environments' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+
+    class TestBlockPlugin < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => Environment},
+          CustomBlock2 => {:type => Enterprise},
+          CustomBlock3 => {:type => Community},
+          CustomBlock4 => {:type => Person},
+        }
+      end
+    end
+
+    Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([TestBlockPlugin.new])
+    assert @controller.available_blocks.include?(CustomBlock1)
+    assert !@controller.available_blocks.include?(CustomBlock2)
+    assert !@controller.available_blocks.include?(CustomBlock3)
+    assert !@controller.available_blocks.include?(CustomBlock4)
+  end
+
+  should 'a block plugin with center position add new blocks only in this position' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+    class CustomBlock5 < Block; end;
+    class CustomBlock6 < Block; end;
+    class CustomBlock7 < Block; end;
+    class CustomBlock8 < Block; end;
+    class CustomBlock9 < Block; end;
+
+    class TestBlockPlugin < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => Environment, :position => [1]},
+          CustomBlock2 => {:type => Environment, :position => 1},
+          CustomBlock3 => {:type => Environment, :position => '1'},
+          CustomBlock4 => {:type => Environment, :position => [2]},
+          CustomBlock5 => {:type => Environment, :position => 2},
+          CustomBlock6 => {:type => Environment, :position => '2'},
+          CustomBlock7 => {:type => Environment, :position => [3]},
+          CustomBlock8 => {:type => Environment, :position => 3},
+          CustomBlock9 => {:type => Environment, :position => '3'},
+        }
+      end
+    end
+
+    Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([TestBlockPlugin.new])
+    login_as(create_admin_user(Environment.default))
+    get :add_block
+
+    assert_response :success
+    assert @controller.instance_variable_get('@center_block_types').include?(CustomBlock1)
+    assert @controller.instance_variable_get('@center_block_types').include?(CustomBlock2)
+    assert @controller.instance_variable_get('@center_block_types').include?(CustomBlock3)
+    assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock4)
+    assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock5)
+    assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock6)
+    assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock7)
+    assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock8)
+    assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock9)
+  end
+
+  should 'a block plugin with side position add new blocks only in this position' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+    class CustomBlock5 < Block; end;
+    class CustomBlock6 < Block; end;
+    class CustomBlock7 < Block; end;
+    class CustomBlock8 < Block; end;
+    class CustomBlock9 < Block; end;
+
+    class TestBlockPlugin < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => Environment, :position => [1]},
+          CustomBlock2 => {:type => Environment, :position => 1},
+          CustomBlock3 => {:type => Environment, :position => '1'},
+          CustomBlock4 => {:type => Environment, :position => [2]},
+          CustomBlock5 => {:type => Environment, :position => 2},
+          CustomBlock6 => {:type => Environment, :position => '2'},
+          CustomBlock7 => {:type => Environment, :position => [3]},
+          CustomBlock8 => {:type => Environment, :position => 3},
+          CustomBlock9 => {:type => Environment, :position => '3'},
+        }
+      end
+    end
+
+    Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([TestBlockPlugin.new])
+    login_as(create_admin_user(Environment.default))
+    get :add_block
+    assert_response :success
+
+    assert !@controller.instance_variable_get('@side_block_types').include?(CustomBlock1)
+    assert !@controller.instance_variable_get('@side_block_types').include?(CustomBlock2)
+    assert !@controller.instance_variable_get('@side_block_types').include?(CustomBlock3)
+    assert @controller.instance_variable_get('@side_block_types').include?(CustomBlock4)
+    assert @controller.instance_variable_get('@side_block_types').include?(CustomBlock5)
+    assert @controller.instance_variable_get('@side_block_types').include?(CustomBlock6)
+    assert @controller.instance_variable_get('@side_block_types').include?(CustomBlock7)
+    assert @controller.instance_variable_get('@side_block_types').include?(CustomBlock8)
+    assert @controller.instance_variable_get('@side_block_types').include?(CustomBlock9)
+  end
+
+  should 'a block plugin cannot be listed for unspecified types' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+    class CustomBlock5 < Block; end;
+    class CustomBlock6 < Block; end;
+    class CustomBlock7 < Block; end;
+    class CustomBlock8 < Block; end;
+
+    class TestBlockPlugin < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => Person, :position => 1},
+          CustomBlock2 => {:type => Community, :position => 1},
+          CustomBlock3 => {:type => Enterprise, :position => 1},
+          CustomBlock4 => {:type => Environment, :position => 1},
+          CustomBlock5 => {:type => Person, :position => 2},
+          CustomBlock6 => {:type => Community, :position => 3},
+          CustomBlock7 => {:type => Enterprise, :position => 2},
+          CustomBlock8 => {:type => Environment, :position => 3},
+        }
+      end
+    end
+
+    Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([TestBlockPlugin.new])
+    login_as(create_admin_user(Environment.default))
+    get :add_block
+    assert_response :success
+
+    assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock1)
+    assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock2)
+    assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock3)
+    assert @controller.instance_variable_get('@center_block_types').include?(CustomBlock4)
+    assert !@controller.instance_variable_get('@side_block_types').include?(CustomBlock5)
+    assert !@controller.instance_variable_get('@side_block_types').include?(CustomBlock6)
+    assert !@controller.instance_variable_get('@side_block_types').include?(CustomBlock7)
+    assert @controller.instance_variable_get('@side_block_types').include?(CustomBlock8)
+  end
+
 end
@@ -4,7 +4,7 @@ require &#39;profile_design_controller&#39;
 class ProfileDesignController; def rescue_action(e) raise e end; end
 class ProfileDesignControllerTest < ActionController::TestCase
-  
+
   COMMOM_BLOCKS = [ ArticleBlock, TagsBlock, RecentDocumentsBlock, ProfileInfoBlock, LinkListBlock, MyNetworkBlock, FeedReaderBlock, ProfileImageBlock, LocationBlock, SlideshowBlock, ProfileSearchBlock, HighlightsBlock ]
   PERSON_BLOCKS = COMMOM_BLOCKS + [FriendsBlock, FavoriteEnterprisesBlock, CommunitiesBlock, EnterprisesBlock ]
   PERSON_BLOCKS_WITH_MEMBERS = PERSON_BLOCKS + [MembersBlock]
@@ -21,7 +21,7 @@ class ProfileDesignControllerTest &lt; ActionController::TestCase
     @profile = @holder = create_user('designtestuser').person
     holder.save!
- 
+
     @box1 = Box.new
     @box2 = Box.new
     @box3 = Box.new
@@ -38,7 +38,7 @@ class ProfileDesignControllerTest &lt; ActionController::TestCase
     @b2 = Block.new
     @box1.blocks << @b2
     @b2.save!
-    
+
     ###### BOX 2
     @b3 = Block.new
     @box2.blocks << @b3
@@ -55,7 +55,7 @@ class ProfileDesignControllerTest &lt; ActionController::TestCase
     @b6 = Block.new
     @box2.blocks << @b6
     @b6.save!
-    
+
     ###### BOX 3
     @b7 = Block.new
     @box3.blocks << @b7
@@ -79,13 +79,13 @@ class ProfileDesignControllerTest &lt; ActionController::TestCase
   def test_local_files_reference
     assert_local_files_reference :get, :index, :profile => 'designtestuser'
   end
-  
+
   def test_valid_xhtml
     assert_valid_xhtml
   end
-  
+
   ######################################################
-  # BEGIN - tests for BoxOrganizerController features 
+  # BEGIN - tests for BoxOrganizerController features
   ######################################################
   def test_should_move_block_to_the_end_of_another_block
     get :move_block, :profile => 'designtestuser', :id => "block-#{@b1.id}", :target => "end-of-box-#{@box2.id}"
@@ -177,12 +177,135 @@ class ProfileDesignControllerTest &lt; ActionController::TestCase
     end
   end
+  should 'a block plugin with center position add new blocks only in this position' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+    class CustomBlock5 < Block; end;
+    class CustomBlock6 < Block; end;
+    class CustomBlock7 < Block; end;
+    class CustomBlock8 < Block; end;
+    class CustomBlock9 < Block; end;
+
+    class TestBlockPlugin < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => Person, :position => [1]},
+          CustomBlock2 => {:type => Person, :position => 1},
+          CustomBlock3 => {:type => Person, :position => '1'},
+          CustomBlock4 => {:type => Person, :position => [2]},
+          CustomBlock5 => {:type => Person, :position => 2},
+          CustomBlock6 => {:type => Person, :position => '2'},
+          CustomBlock7 => {:type => Person, :position => [3]},
+          CustomBlock8 => {:type => Person, :position => 3},
+          CustomBlock9 => {:type => Person, :position => '3'},
+        }
+      end
+    end
+
+    Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([TestBlockPlugin.new])
+    get :add_block, :profile => 'designtestuser'
+    assert_response :success
+
+    assert @controller.instance_variable_get('@center_block_types').include?(CustomBlock1)
+    assert @controller.instance_variable_get('@center_block_types').include?(CustomBlock2)
+    assert @controller.instance_variable_get('@center_block_types').include?(CustomBlock3)
+    assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock4)
+    assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock5)
+    assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock6)
+    assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock7)
+    assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock8)
+    assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock9)
+  end
+
+  should 'a block plugin with side position add new blocks only in this position' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+    class CustomBlock5 < Block; end;
+    class CustomBlock6 < Block; end;
+    class CustomBlock7 < Block; end;
+    class CustomBlock8 < Block; end;
+    class CustomBlock9 < Block; end;
+
+    class TestBlockPlugin < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => Person, :position => [1]},
+          CustomBlock2 => {:type => Person, :position => 1},
+          CustomBlock3 => {:type => Person, :position => '1'},
+          CustomBlock4 => {:type => Person, :position => [2]},
+          CustomBlock5 => {:type => Person, :position => 2},
+          CustomBlock6 => {:type => Person, :position => '2'},
+          CustomBlock7 => {:type => Person, :position => [3]},
+          CustomBlock8 => {:type => Person, :position => 3},
+          CustomBlock9 => {:type => Person, :position => '3'},
+        }
+      end
+    end
+
+    Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([TestBlockPlugin.new])
+    get :add_block, :profile => 'designtestuser'
+    assert_response :success
+
+    assert !@controller.instance_variable_get('@side_block_types').include?(CustomBlock1)
+    assert !@controller.instance_variable_get('@side_block_types').include?(CustomBlock2)
+    assert !@controller.instance_variable_get('@side_block_types').include?(CustomBlock3)
+    assert @controller.instance_variable_get('@side_block_types').include?(CustomBlock4)
+    assert @controller.instance_variable_get('@side_block_types').include?(CustomBlock5)
+    assert @controller.instance_variable_get('@side_block_types').include?(CustomBlock6)
+    assert @controller.instance_variable_get('@side_block_types').include?(CustomBlock7)
+    assert @controller.instance_variable_get('@side_block_types').include?(CustomBlock8)
+    assert @controller.instance_variable_get('@side_block_types').include?(CustomBlock9)
+  end
+
+  should 'a block plugin cannot be listed for unspecified types' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+    class CustomBlock5 < Block; end;
+    class CustomBlock6 < Block; end;
+    class CustomBlock7 < Block; end;
+    class CustomBlock8 < Block; end;
+
+    class TestBlockPlugin < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => Person, :position => 1},
+          CustomBlock2 => {:type => Community, :position => 1},
+          CustomBlock3 => {:type => Enterprise, :position => 1},
+          CustomBlock4 => {:type => Environment, :position => 1},
+          CustomBlock5 => {:type => Person, :position => 2},
+          CustomBlock6 => {:type => Community, :position => 3},
+          CustomBlock7 => {:type => Enterprise, :position => 2},
+          CustomBlock8 => {:type => Environment, :position => 3},
+        }
+      end
+    end
+
+    Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([TestBlockPlugin.new])
+    get :add_block, :profile => 'designtestuser'
+    assert_response :success
+
+    assert @controller.instance_variable_get('@center_block_types').include?(CustomBlock1)
+    assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock2)
+    assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock3)
+    assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock4)
+    assert @controller.instance_variable_get('@side_block_types').include?(CustomBlock5)
+    assert !@controller.instance_variable_get('@side_block_types').include?(CustomBlock6)
+    assert !@controller.instance_variable_get('@side_block_types').include?(CustomBlock7)
+    assert !@controller.instance_variable_get('@side_block_types').include?(CustomBlock8)
+  end
+
   ######################################################
-  # END - tests for BoxOrganizerController features 
+  # END - tests for BoxOrganizerController features
   ######################################################
   ######################################################
-  # BEGIN - tests for ProfileDesignController features 
+  # BEGIN - tests for ProfileDesignController features
   ######################################################
   should 'display popup for adding a new block' do
@@ -285,10 +408,10 @@ class ProfileDesignControllerTest &lt; ActionController::TestCase
   should 'create back link to profile control panel' do
     p = Profile.create!(:name => 'test_profile', :identifier => 'test_profile')
-   
+
     login_as(create_user_with_permission('test_user','edit_profile_design',p).identifier )
     get :index, :profile => p.identifier
-    
+
     assert_tag :tag => 'a', :attributes => {:href => '/myprofile/test_profile'}
   end
@@ -349,6 +472,7 @@ class ProfileDesignControllerTest &lt; ActionController::TestCase
     profile = mock
     profile.stubs(:has_members?).returns(false)
     profile.stubs(:person?).returns(true)
+    profile.stubs(:community?).returns(true)
     profile.stubs(:enterprise?).returns(false)
     profile.stubs(:has_blog?).returns(false)
     profile.stubs(:is_admin?).with(anything).returns(false)
@@ -357,6 +481,7 @@ class ProfileDesignControllerTest &lt; ActionController::TestCase
     environment.stubs(:enabled?).returns(false)
     @controller.stubs(:profile).returns(profile)
     @controller.stubs(:user).returns(profile)
+    Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([])
     assert_equal PERSON_BLOCKS, @controller.available_blocks
   end
@@ -364,6 +489,7 @@ class ProfileDesignControllerTest &lt; ActionController::TestCase
     profile = mock
     profile.stubs(:has_members?).returns(true)
     profile.stubs(:person?).returns(true)
+    profile.stubs(:community?).returns(true)
     profile.stubs(:enterprise?).returns(false)
     profile.stubs(:has_blog?).returns(false)
     profile.stubs(:is_admin?).with(anything).returns(false)
@@ -372,6 +498,7 @@ class ProfileDesignControllerTest &lt; ActionController::TestCase
     environment.stubs(:enabled?).returns(false)
     @controller.stubs(:profile).returns(profile)
     @controller.stubs(:user).returns(profile)
+    Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([])
     assert_equal [], @controller.available_blocks - PERSON_BLOCKS_WITH_MEMBERS
   end
@@ -379,6 +506,7 @@ class ProfileDesignControllerTest &lt; ActionController::TestCase
     profile = mock
     profile.stubs(:has_members?).returns(false)
     profile.stubs(:person?).returns(true)
+    profile.stubs(:community?).returns(true)
     profile.stubs(:enterprise?).returns(false)
     profile.stubs(:has_blog?).returns(true)
     profile.stubs(:is_admin?).with(anything).returns(false)
@@ -387,6 +515,7 @@ class ProfileDesignControllerTest &lt; ActionController::TestCase
     environment.stubs(:enabled?).returns(false)
     @controller.stubs(:profile).returns(profile)
     @controller.stubs(:user).returns(profile)
+    Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([])
     assert_equal [], @controller.available_blocks - PERSON_BLOCKS_WITH_BLOG
   end
@@ -394,6 +523,7 @@ class ProfileDesignControllerTest &lt; ActionController::TestCase
     profile = mock
     profile.stubs(:has_members?).returns(false)
     profile.stubs(:person?).returns(false)
+    profile.stubs(:community?).returns(true)
     profile.stubs(:enterprise?).returns(true)
     profile.stubs(:has_blog?).returns(false)
     profile.stubs(:is_admin?).with(anything).returns(false)
@@ -402,6 +532,7 @@ class ProfileDesignControllerTest &lt; ActionController::TestCase
     environment.stubs(:enabled?).returns(true)
     @controller.stubs(:profile).returns(profile)
     @controller.stubs(:user).returns(profile)
+    Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([])
     assert_equal [], @controller.available_blocks - ENTERPRISE_BLOCKS
   end
@@ -409,6 +540,7 @@ class ProfileDesignControllerTest &lt; ActionController::TestCase
     profile = mock
     profile.stubs(:has_members?).returns(false)
     profile.stubs(:person?).returns(false)
+    profile.stubs(:community?).returns(true)
     profile.stubs(:enterprise?).returns(true)
     profile.stubs(:has_blog?).returns(false)
     profile.stubs(:is_admin?).with(anything).returns(false)
@@ -417,6 +549,7 @@ class ProfileDesignControllerTest &lt; ActionController::TestCase
     environment.stubs(:enabled?).returns(false)
     @controller.stubs(:profile).returns(profile)
     @controller.stubs(:user).returns(profile)
+    Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([])
     assert_equal [], @controller.available_blocks - ENTERPRISE_BLOCKS_WITH_PRODUCTS_ENABLE
   end
@@ -441,4 +574,144 @@ class ProfileDesignControllerTest &lt; ActionController::TestCase
     assert_tag :tag => 'option', :attributes => {:value => selected_article.id, :selected => 'selected'}
   end
+  should 'the block plugin add a new block' do
+    profile = mock
+    profile.stubs(:has_members?).returns(false)
+    profile.stubs(:person?).returns(true)
+    profile.stubs(:community?).returns(true)
+    profile.stubs(:enterprise?).returns(false)
+    profile.stubs(:has_blog?).returns(false)
+    profile.stubs(:is_admin?).with(anything).returns(false)
+    environment = mock
+    profile.stubs(:environment).returns(environment)
+    environment.stubs(:enabled?).returns(false)
+    @controller.stubs(:profile).returns(profile)
+    @controller.stubs(:user).returns(profile)
+
+    class CustomBlock1 < Block; end;
+
+    class TestBlockPlugin < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {},
+        }
+      end
+    end
+
+    Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([TestBlockPlugin.new])
+    assert @controller.available_blocks.include?(CustomBlock1)
+  end
+
+  should 'a person block plugin add new blocks for person profile' do
+    profile = mock
+    profile.stubs(:has_members?).returns(false)
+    profile.stubs(:person?).returns(true)
+    profile.stubs(:community?).returns(false)
+    profile.stubs(:enterprise?).returns(false)
+    profile.stubs(:has_blog?).returns(false)
+    profile.stubs(:is_admin?).with(anything).returns(false)
+    environment = mock
+    profile.stubs(:environment).returns(environment)
+    environment.stubs(:enabled?).returns(false)
+    @controller.stubs(:profile).returns(profile)
+    @controller.stubs(:user).returns(profile)
+
+    class CustomBlock1 < Block; end;
+
+    class TestBlockPlugin < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => Person},
+        }
+      end
+    end
+
+    Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([TestBlockPlugin.new])
+    assert @controller.available_blocks.include?(CustomBlock1)
+  end
+
+  should 'a community block plugin add new blocks for community profile' do
+    profile = mock
+    profile.stubs(:has_members?).returns(false)
+    profile.stubs(:person?).returns(false)
+    profile.stubs(:community?).returns(true)
+    profile.stubs(:enterprise?).returns(false)
+    profile.stubs(:has_blog?).returns(false)
+    profile.stubs(:is_admin?).with(anything).returns(false)
+    environment = mock
+    profile.stubs(:environment).returns(environment)
+    environment.stubs(:enabled?).returns(false)
+    @controller.stubs(:profile).returns(profile)
+    @controller.stubs(:user).returns(profile)
+
+    class CustomBlock1 < Block; end;
+
+    class TestBlockPlugin < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => Community},
+        }
+      end
+    end
+
+    Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([TestBlockPlugin.new])
+    assert @controller.available_blocks.include?(CustomBlock1)
+  end
+
+  should 'a enterprise block plugin add new blocks for enterprise profile' do
+    profile = mock
+    profile.stubs(:has_members?).returns(false)
+    profile.stubs(:person?).returns(false)
+    profile.stubs(:community?).returns(false)
+    profile.stubs(:enterprise?).returns(true)
+    profile.stubs(:has_blog?).returns(false)
+    profile.stubs(:is_admin?).with(anything).returns(false)
+    environment = mock
+    profile.stubs(:environment).returns(environment)
+    environment.stubs(:enabled?).returns(false)
+    @controller.stubs(:profile).returns(profile)
+    @controller.stubs(:user).returns(profile)
+
+    class CustomBlock1 < Block; end;
+
+    class TestBlockPlugin < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => Enterprise},
+        }
+      end
+    end
+
+    Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([TestBlockPlugin.new])
+    assert @controller.available_blocks.include?(CustomBlock1)
+  end
+
+  should 'an environment block plugin not add new blocks for enterprise, person or community profiles' do
+    profile = mock
+    profile.stubs(:has_members?).returns(false)
+    profile.stubs(:person?).returns(true)
+    profile.stubs(:community?).returns(true)
+    profile.stubs(:enterprise?).returns(true)
+    profile.stubs(:has_blog?).returns(false)
+    profile.stubs(:is_admin?).with(anything).returns(false)
+    environment = mock
+    profile.stubs(:environment).returns(environment)
+    environment.stubs(:enabled?).returns(false)
+    @controller.stubs(:profile).returns(profile)
+    @controller.stubs(:user).returns(profile)
+
+    class CustomBlock1 < Block; end;
+
+    class TestBlockPlugin < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => Environment},
+        }
+      end
+    end
+
+    Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([TestBlockPlugin.new])
+    assert !@controller.available_blocks.include?(CustomBlock1)
+  end
+
 end
@@ -26,4 +26,476 @@ class PluginTest &lt; ActiveSupport::TestCase
     assert_equal({:controller => 'plugin_test/plugin1_admin', :action => 'index'}, Plugin1.admin_url)
   end
+  should 'returns empty hash for class method extra_blocks by default if no blocks are defined on plugin' do
+    
+    class SomePlugin1 < Noosfero::Plugin
+    end
+
+    assert_equal({}, SomePlugin1.extra_blocks)
+  end
+
+  should 'returns empty array for instance method extra_blocks by default if no blocks are defined on plugin' do
+    class Plugin1 < Noosfero::Plugin
+       def self.extra_blocks
+       end
+    end
+    p = Plugin1.new
+    assert_equal([], p.extra_blocks)
+  end
+
+  should 'returns empty array for instance method extra_blocks by default if nil is returned' do
+    class Plugin1 < Noosfero::Plugin
+       def self.extra_blocks
+         nil
+       end
+    end
+    p = Plugin1.new
+    assert_equal([], p.extra_blocks)
+  end
+
+  should 'returns the blocks implemented by plugin' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+
+    class Plugin1 < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {},
+          CustomBlock2 => {}
+        }
+      end
+    end
+    p = Plugin1.new
+    assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks)
+    assert_equal([], p.extra_blocks - [CustomBlock1, CustomBlock2])
+  end
+
+  should 'returns only person block and non defined types block if type person is specified' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+    class CustomBlock5 < Block; end;
+
+    class Plugin1 < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => 'person'},
+          CustomBlock2 => {},
+          CustomBlock3 => {:type => 'enterprise'},
+          CustomBlock4 => {:type => 'community'},
+          CustomBlock5 => {:type => 'environment'},
+        }
+      end
+    end
+    p = Plugin1.new
+    assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:type => Person))
+    assert_equal([],  p.extra_blocks(:type => Person) - [CustomBlock1, CustomBlock2])
+  end
+
+  should 'returns only community block and non defined types block if type community is specified' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+    class CustomBlock5 < Block; end;
+
+    class Plugin1 < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => 'community'},
+          CustomBlock2 => {},
+          CustomBlock3 => {:type => 'person'},
+          CustomBlock4 => {:type => 'enterprise'},
+          CustomBlock5 => {:type => 'environment'},
+        }
+      end
+    end
+    p = Plugin1.new
+    assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:type => Community))
+    assert_equal([],  p.extra_blocks(:type => Community) - [CustomBlock1, CustomBlock2])
+  end
+
+  should 'returns only enterprise block and non defined types block if type enterprise is specified' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+    class CustomBlock5 < Block; end;
+
+    class Plugin1 < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => 'enterprise'},
+          CustomBlock2 => {},
+          CustomBlock3 => {:type => 'person'},
+          CustomBlock4 => {:type => 'community'},
+          CustomBlock5 => {:type => 'environment'},
+        }
+      end
+    end
+    p = Plugin1.new
+    assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:type => Enterprise))
+    assert_equal([],  p.extra_blocks(:type => Enterprise) - [CustomBlock1, CustomBlock2])
+  end
+
+  should 'returns only environment block and non defined types block if type environment is specified' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+    class CustomBlock5 < Block; end;
+
+    class Plugin1 < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => 'environment'},
+          CustomBlock2 => {},
+          CustomBlock3 => {:type => 'enterprise'},
+          CustomBlock4 => {:type => 'community'},
+          CustomBlock5 => {:type => 'person'},
+        }
+      end
+    end
+    p = Plugin1.new
+    assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:type => Environment))
+    assert_equal([],  p.extra_blocks(:type => Environment) - [CustomBlock1, CustomBlock2])
+  end
+
+  should 'returns array of blocks of a specified type' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+    class CustomBlock5 < Block; end;
+
+    class Plugin1 < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => 'person'},
+          CustomBlock2 => {:type => 'person'},
+          CustomBlock3 => {:type => 'environment'},
+          CustomBlock4 => {:type => 'enterprise'},
+          CustomBlock5 => {:type => 'community'},
+        }
+      end
+    end
+    p = Plugin1.new
+    assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:type => Person))
+    assert_equal([], p.extra_blocks(:type => Person) - [CustomBlock1, CustomBlock2])
+  end
+
+  should 'returns all blocks without type if no type is specified' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+    class CustomBlock5 < Block; end;
+    class CustomBlock6 < Block; end;
+
+    class Plugin1 < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => 'person'},
+          CustomBlock2 => {:type => 'environment'},
+          CustomBlock3 => {:type => 'enterprise'},
+          CustomBlock4 => {:type => 'community'},
+          CustomBlock5 => {},
+          CustomBlock6 => {},
+        }
+      end
+    end
+    p = Plugin1.new
+    assert_equal([], [CustomBlock5, CustomBlock6] - p.extra_blocks)
+    assert_equal([], p.extra_blocks - [CustomBlock5, CustomBlock6])
+  end
+
+  should 'returns all blocks if type all is specified as parameter' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+    class CustomBlock5 < Block; end;
+    class CustomBlock6 < Block; end;
+
+    class Plugin1 < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => 'person'},
+          CustomBlock2 => {:type => 'environment'},
+          CustomBlock3 => {:type => 'enterprise'},
+          CustomBlock4 => {:type => 'community'},
+          CustomBlock5 => {},
+          CustomBlock6 => {},
+        }
+      end
+    end
+    p = Plugin1.new
+    assert_equal([], [CustomBlock1, CustomBlock2, CustomBlock3, CustomBlock4, CustomBlock5, CustomBlock6] - p.extra_blocks(:type => :all))
+    assert_equal([], p.extra_blocks(:type => :all) - [CustomBlock1, CustomBlock2, CustomBlock3, CustomBlock4, CustomBlock5, CustomBlock6])
+  end
+
+
+  should 'returns blocks of specified types' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+
+    class Plugin1 < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => ['person', 'environment']},
+          CustomBlock2 => {:type => 'environment'},
+          CustomBlock3 => {:type => 'enterprise'},
+          CustomBlock4 => {:type => 'community'},
+        }
+      end
+    end
+    p = Plugin1.new
+    assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:type => Environment))
+    assert_equal([], p.extra_blocks(:type => Environment) - [CustomBlock1, CustomBlock2])
+  end
+
+  should 'returns blocks of with types passed as string or constant' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+    class CustomBlock5 < Block; end;
+
+    class Plugin1 < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => ['person', 'environment']},
+          CustomBlock2 => {:type => 'environment'},
+          CustomBlock3 => {:type => Environment},
+          CustomBlock4 => {:type => [Environment]},
+          CustomBlock5 => {:type => 'person'},
+        }
+      end
+    end
+    p = Plugin1.new
+    assert_equal([], [CustomBlock1, CustomBlock2, CustomBlock3, CustomBlock4] - p.extra_blocks(:type => Environment))
+    assert_equal([], p.extra_blocks(:type => Environment) - [CustomBlock1, CustomBlock2, CustomBlock3, CustomBlock4])
+  end
+
+  should 'through exception if undefined type is specified as parameter' do
+    class CustomBlock1 < Block; end;
+
+    class Plugin1 < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => 'undefined_type'},
+        }
+      end
+    end
+    p = Plugin1.new
+
+    assert_raise NameError do
+      p.extra_blocks
+    end
+  end
+
+  should 'returns only position 1 block and non defined position block if position 1 is specified' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+
+    class Plugin1 < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:position => 1},
+          CustomBlock2 => {},
+          CustomBlock3 => {:position => 3},
+          CustomBlock4 => {:position => 2},
+        }
+      end
+    end
+    p = Plugin1.new
+    assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:position => 1))
+    assert_equal([],  p.extra_blocks(:position => 1) - [CustomBlock1, CustomBlock2])
+  end
+
+  should 'returns only position 2 block and non defined position block if position 2 is specified' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+
+    class Plugin1 < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:position => 2},
+          CustomBlock2 => {},
+          CustomBlock3 => {:position => 3},
+          CustomBlock4 => {:position => 1},
+        }
+      end
+    end
+    p = Plugin1.new
+    assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:position => 2))
+    assert_equal([],  p.extra_blocks(:position => 2) - [CustomBlock1, CustomBlock2])
+  end
+
+  should 'returns only position 3 block and non defined position block if position 3 is specified' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+
+    class Plugin1 < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:position => 3},
+          CustomBlock2 => {},
+          CustomBlock3 => {:position => 1},
+          CustomBlock4 => {:position => 2},
+        }
+      end
+    end
+    p = Plugin1.new
+    assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:position => 3))
+    assert_equal([],  p.extra_blocks(:position => 3) - [CustomBlock1, CustomBlock2])
+  end
+
+  should 'returns array of blocks of a specified position' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+
+    class Plugin1 < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:position => 1 },
+          CustomBlock2 => {:position => 1 },
+          CustomBlock3 => {:position => 2},
+          CustomBlock4 => {:position => 3},
+        }
+      end
+    end
+    p = Plugin1.new
+    assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:position => 1))
+    assert_equal([], p.extra_blocks(:position => 1) - [CustomBlock1, CustomBlock2])
+  end
+
+  should 'returns array of blocks of a specified position wihout any type' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+    class CustomBlock5 < Block; end;
+    class CustomBlock6 < Block; end;
+    class CustomBlock7 < Block; end;
+    class CustomBlock8 < Block; end;
+    class CustomBlock9 < Block; end;
+    class CustomBlock10 < Block; end;
+
+    class Plugin1 < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => Person, :position => 1 },
+          CustomBlock2 => {:type => Community, :position => 1 },
+          CustomBlock3 => {:type => Enterprise, :position => 1 },
+          CustomBlock4 => {:type => Environment, :position => 1 },
+          CustomBlock5 => {:position => 1 },
+          CustomBlock6 => {:type => Person, :position => [1,2,3] },
+          CustomBlock7 => {:type => Community, :position => [1,2,3] },
+          CustomBlock8 => {:type => Enterprise, :position => [1,2,3] },
+          CustomBlock9 => {:type => Environment, :position => [1,2,3] },
+          CustomBlock10 => {:position => [1,2,3] },
+        }
+      end
+    end
+    p = Plugin1.new
+    assert_equal([], [CustomBlock5, CustomBlock10] - p.extra_blocks(:position => 1))
+    assert_equal([], p.extra_blocks(:position => 1) - [CustomBlock5, CustomBlock10])
+  end
+
+  should 'returns blocks of all position if no position is specified' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+
+    class Plugin1 < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:position => 1 },
+          CustomBlock2 => {:position => 2},
+          CustomBlock3 => {:position => 3},
+          CustomBlock4 => {},
+        }
+      end
+    end
+    p = Plugin1.new
+    assert_equal([], [CustomBlock1, CustomBlock2, CustomBlock3, CustomBlock4] - p.extra_blocks)
+    assert_equal([], p.extra_blocks - [CustomBlock1, CustomBlock2, CustomBlock3, CustomBlock4])
+  end
+
+  should 'returns blocks of specified positions' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+
+    class Plugin1 < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:position => [1, 2]},
+          CustomBlock2 => {:position => 2},
+          CustomBlock3 => {:position => 3},
+        }
+      end
+    end
+    p = Plugin1.new
+    assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:position => 2))
+    assert_equal([], p.extra_blocks(:position => 2) - [CustomBlock1, CustomBlock2])
+  end
+
+  should 'returns blocks of with positions passed as string or numbers' do
+    class CustomBlock1 < Block; end;
+    class CustomBlock2 < Block; end;
+    class CustomBlock3 < Block; end;
+    class CustomBlock4 < Block; end;
+    class CustomBlock5 < Block; end;
+
+    class Plugin1 < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:position => [1, '2']},
+          CustomBlock2 => {:position => '2'},
+          CustomBlock3 => {:position => 2},
+          CustomBlock4 => {:position => [2]},
+          CustomBlock5 => {:position => '1'},
+        }
+      end
+    end
+    p = Plugin1.new
+    assert_equal([], [CustomBlock1, CustomBlock2, CustomBlock3, CustomBlock4] - p.extra_blocks(:position => 2))
+    assert_equal([], p.extra_blocks(:position => 2) - [CustomBlock1, CustomBlock2, CustomBlock3, CustomBlock4])
+  end
+
+  should 'through exception if undefined position is specified as parameter' do
+    class CustomBlock1 < Block; end;
+
+    class Plugin1 < Noosfero::Plugin
+      def self.extra_blocks
+        {
+          CustomBlock1 => {:type => 'undefined_type'},
+        }
+      end
+    end
+    p = Plugin1.new
+
+    assert_raise NameError do
+      p.extra_blocks
+    end
+  end
+
+
+
+
+
 end
	@@ -4,6 +4,7 @@ class EnvironmentDesignController < BoxOrganizerController		@@ -4,6 +4,7 @@ class EnvironmentDesignController < BoxOrganizerController
4		4
5	def available_blocks	5	def available_blocks
6	@available_blocks \|\|= [ ArticleBlock, LoginBlock, EnvironmentStatisticsBlock, RecentDocumentsBlock, EnterprisesBlock, CommunitiesBlock, PeopleBlock, SellersSearchBlock, LinkListBlock, FeedReaderBlock, SlideshowBlock, HighlightsBlock, FeaturedProductsBlock, CategoriesBlock, RawHTMLBlock, TagsBlock ]	6	@available_blocks \|\|= [ ArticleBlock, LoginBlock, EnvironmentStatisticsBlock, RecentDocumentsBlock, EnterprisesBlock, CommunitiesBlock, PeopleBlock, SellersSearchBlock, LinkListBlock, FeedReaderBlock, SlideshowBlock, HighlightsBlock, FeaturedProductsBlock, CategoriesBlock, RawHTMLBlock, TagsBlock ]
		7	+ @available_blocks += plugins.dispatch(:extra_blocks, :type => Environment)
7	end	8	end
8		9
9	end	10	end
	@@ -97,6 +97,35 @@ class Noosfero::Plugin		@@ -97,6 +97,35 @@ class Noosfero::Plugin
97	ERB.new(File.read("#{views_path}/#{file_path}")).result(binding)	97	ERB.new(File.read("#{views_path}/#{file_path}")).result(binding)
98	end	98	end
99		99
		100	+ def extra_blocks(params = {})
		101	+ return [] if self.class.extra_blocks.nil?
		102	+ blocks = self.class.extra_blocks.map do \|block, options\|
		103	+ type = options[:type]
		104	+ type = type.is_a?(Array) ? type : [type].compact
		105	+ type = type.map do \|x\|
		106	+ x.is_a?(String) ? x.capitalize.constantize : x
		107	+ end
		108	+ raise "This is not a valid type" if !type.empty? && ![Person, Community, Enterprise, Environment].detect{\|m\| type.include?(m)}
		109	+
		110	+ position = options[:position]
		111	+ position = position.is_a?(Array) ? position : [position].compact
		112	+ position = position.map{\|p\| p.to_i}
		113	+ raise "This is not a valid position" if !position.empty? && ![1,2,3].detect{\|m\| position.include?(m)}
		114	+
		115	+ if !type.empty? && (params[:type] != :all)
		116	+ block = type.include?(params[:type]) ? block : nil
		117	+ end
		118	+
		119	+ if !position.empty? && !params[:position].nil?
		120	+ block = position.detect{ \|p\| [params[:position]].flatten.include?(p)} ? block : nil
		121	+ end
		122	+
		123	+ block
		124	+ end
		125	+ blocks.compact!
		126	+ blocks \|\| []
		127	+ end
		128	+
100	# Here the developer may specify the events to which the plugins can	129	# Here the developer may specify the events to which the plugins can
101	# register and must return true or false. The default value must be false.	130	# register and must return true or false. The default value must be false.
102		131
	@@ -351,6 +380,60 @@ class Noosfero::Plugin		@@ -351,6 +380,60 @@ class Noosfero::Plugin
351	nil	380	nil
352	end	381	end
353		382
		383	+ # -> Adds additional blocks to profiles and environments.
		384	+ # Your plugin must implements a class method called 'extra_blocks'
		385	+ # that returns a hash with the following syntax.
		386	+ # {
		387	+ # 'block_name' =>
		388	+ # {
		389	+ # :type => 'for which holder the block will be available',
		390	+ # :position => 'where the block could be displayed'
		391	+ # }
		392	+ # }
		393	+ #
		394	+ # Where:
		395	+ #
		396	+ # - block_name: Name of the new block added to the blocks list
		397	+ # - type: Might have some of the values
		398	+ # - 'environment' or Environment: If the block is available only for Environment models
		399	+ # - 'community' or Community: If the block is available only for Community models
		400	+ # - 'enterprise' or Enterprise: If the block is available only for Enterprise models
		401	+ # - 'person' or Person: If the block is available only for Person models
		402	+ # - nil: If no type parameter is passed the block will be available for all types
		403	+ # - position: Is the layout position of the block. It should be:
		404	+ # - '1' or 1: Area 1 of layout
		405	+ # - '2' or 2: Area 2 of layout
		406	+ # - '3' or 3: Area 3 of layout
		407	+ # - nil: If no position parameter is passed the block will be available for all positions
		408	+ #
		409	+ # OBS: Area 1 is where stay the main content of layout. Areas 2 and 3 are the sides of layout.
		410	+ #
		411	+ # examples:
		412	+ #
		413	+ # def self.extra_blocks(params)
		414	+ # {
		415	+ # #Display 'CustomBlock1' only for 'Person' on position '1'
		416	+ # CustomBlock1 => {:type => 'person', :position => '1' },
		417	+ #
		418	+ # #Display 'CustomBlock2' only for 'Community' on position '2'
		419	+ # CustomBlock2 => {:type => Community, :position => '2' },
		420	+ #
		421	+ # #Display 'CustomBlock3' only for 'Enterprise' on position '3'
		422	+ # CustomBlock3 => {:type => 'enterprise', :position => 3 },
		423	+ #
		424	+ # #Display 'CustomBlock2' for 'Environment' and 'Person' on positions '1' and '3'
		425	+ # CustomBlock4 => {:type => ['environment', Person], :position => ['1','3'] },
		426	+ #
		427	+ # #Display 'CustomBlock5' for all types and all positions
		428	+ # CustomBlock5 => {},
		429	+ # }
		430	+ # end
		431	+ #
		432	+ # OBS: The default value is a empty hash.
		433	+ def self.extra_blocks
		434	+ {}
		435	+ end
		436	+
354	def method_missing(method, *args, &block)	437	def method_missing(method, *args, &block)
355	# This is a generic hotspot for all controllers on Noosfero.	438	# This is a generic hotspot for all controllers on Noosfero.
356	# If any plugin wants to define filters to run on any controller, the name of	439	# If any plugin wants to define filters to run on any controller, the name of
	@@ -12,22 +12,23 @@ class EnvironmentDesignControllerTest < ActionController::TestCase		@@ -12,22 +12,23 @@ class EnvironmentDesignControllerTest < ActionController::TestCase
12	@controller = EnvironmentDesignController.new	12	@controller = EnvironmentDesignController.new
13	@request = ActionController::TestRequest.new	13	@request = ActionController::TestRequest.new
14	@response = ActionController::TestResponse.new	14	@response = ActionController::TestResponse.new
		15	+ Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([])
15	end	16	end
16		17
17	def test_local_files_reference	18	def test_local_files_reference
18	assert_local_files_reference	19	assert_local_files_reference
19	end	20	end
20	-	21	+
21	def test_valid_xhtml	22	def test_valid_xhtml
22	assert_valid_xhtml	23	assert_valid_xhtml
23	end	24	end
24	-	25	+
25	should 'indicate only actual blocks as such' do	26	should 'indicate only actual blocks as such' do
26	assert(@controller.available_blocks.all? {\|item\| item.new.is_a? Block})	27	assert(@controller.available_blocks.all? {\|item\| item.new.is_a? Block})
27	end	28	end
28		29
29	ALL_BLOCKS.map do \|block\|	30	ALL_BLOCKS.map do \|block\|
30	- define_method "test_should_#{block.to_s}_is_available" do	31	+ define_method "test_should_#{block.to_s}_is_available" do
31	assert_includes @controller.available_blocks,block	32	assert_includes @controller.available_blocks,block
32	end	33	end
33	end	34	end
	@@ -191,7 +192,7 @@ class EnvironmentDesignControllerTest < ActionController::TestCase		@@ -191,7 +192,7 @@ class EnvironmentDesignControllerTest < ActionController::TestCase
191		192
192	assert_tag :tag => 'a', :attributes => {:href => '/admin'}, :child => {:tag => 'span', :content => "Back to control panel"}	193	assert_tag :tag => 'a', :attributes => {:href => '/admin'}, :child => {:tag => 'span', :content => "Back to control panel"}
193	end	194	end
194	-	195	+
195	should 'render add a new block functionality' do	196	should 'render add a new block functionality' do
196	login_as(create_admin_user(Environment.default))	197	login_as(create_admin_user(Environment.default))
197	get :add_block	198	get :add_block
	@@ -199,4 +200,170 @@ class EnvironmentDesignControllerTest < ActionController::TestCase		@@ -199,4 +200,170 @@ class EnvironmentDesignControllerTest < ActionController::TestCase
199	assert_response :success	200	assert_response :success
200	assert_template 'add_block'	201	assert_template 'add_block'
201	end	202	end
		203	+
		204	+ should 'a environment block plugin add new blocks for environments' do
		205	+ class CustomBlock1 < Block; end;
		206	+
		207	+ class TestBlockPlugin < Noosfero::Plugin
		208	+ def self.extra_blocks
		209	+ {
		210	+ CustomBlock1 => {:type => Environment},
		211	+ }
		212	+ end
		213	+ end
		214	+
		215	+ Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([TestBlockPlugin.new])
		216	+ assert @controller.available_blocks.include?(CustomBlock1)
		217	+ end
		218	+
		219	+ should 'a person, enterprise and community blocks plugins do not add new blocks for environments' do
		220	+ class CustomBlock1 < Block; end;
		221	+ class CustomBlock2 < Block; end;
		222	+ class CustomBlock3 < Block; end;
		223	+ class CustomBlock4 < Block; end;
		224	+
		225	+ class TestBlockPlugin < Noosfero::Plugin
		226	+ def self.extra_blocks
		227	+ {
		228	+ CustomBlock1 => {:type => Environment},
		229	+ CustomBlock2 => {:type => Enterprise},
		230	+ CustomBlock3 => {:type => Community},
		231	+ CustomBlock4 => {:type => Person},
		232	+ }
		233	+ end
		234	+ end
		235	+
		236	+ Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([TestBlockPlugin.new])
		237	+ assert @controller.available_blocks.include?(CustomBlock1)
		238	+ assert !@controller.available_blocks.include?(CustomBlock2)
		239	+ assert !@controller.available_blocks.include?(CustomBlock3)
		240	+ assert !@controller.available_blocks.include?(CustomBlock4)
		241	+ end
		242	+
		243	+ should 'a block plugin with center position add new blocks only in this position' do
		244	+ class CustomBlock1 < Block; end;
		245	+ class CustomBlock2 < Block; end;
		246	+ class CustomBlock3 < Block; end;
		247	+ class CustomBlock4 < Block; end;
		248	+ class CustomBlock5 < Block; end;
		249	+ class CustomBlock6 < Block; end;
		250	+ class CustomBlock7 < Block; end;
		251	+ class CustomBlock8 < Block; end;
		252	+ class CustomBlock9 < Block; end;
		253	+
		254	+ class TestBlockPlugin < Noosfero::Plugin
		255	+ def self.extra_blocks
		256	+ {
		257	+ CustomBlock1 => {:type => Environment, :position => [1]},
		258	+ CustomBlock2 => {:type => Environment, :position => 1},
		259	+ CustomBlock3 => {:type => Environment, :position => '1'},
		260	+ CustomBlock4 => {:type => Environment, :position => [2]},
		261	+ CustomBlock5 => {:type => Environment, :position => 2},
		262	+ CustomBlock6 => {:type => Environment, :position => '2'},
		263	+ CustomBlock7 => {:type => Environment, :position => [3]},
		264	+ CustomBlock8 => {:type => Environment, :position => 3},
		265	+ CustomBlock9 => {:type => Environment, :position => '3'},
		266	+ }
		267	+ end
		268	+ end
		269	+
		270	+ Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([TestBlockPlugin.new])
		271	+ login_as(create_admin_user(Environment.default))
		272	+ get :add_block
		273	+
		274	+ assert_response :success
		275	+ assert @controller.instance_variable_get('@center_block_types').include?(CustomBlock1)
		276	+ assert @controller.instance_variable_get('@center_block_types').include?(CustomBlock2)
		277	+ assert @controller.instance_variable_get('@center_block_types').include?(CustomBlock3)
		278	+ assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock4)
		279	+ assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock5)
		280	+ assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock6)
		281	+ assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock7)
		282	+ assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock8)
		283	+ assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock9)
		284	+ end
		285	+
		286	+ should 'a block plugin with side position add new blocks only in this position' do
		287	+ class CustomBlock1 < Block; end;
		288	+ class CustomBlock2 < Block; end;
		289	+ class CustomBlock3 < Block; end;
		290	+ class CustomBlock4 < Block; end;
		291	+ class CustomBlock5 < Block; end;
		292	+ class CustomBlock6 < Block; end;
		293	+ class CustomBlock7 < Block; end;
		294	+ class CustomBlock8 < Block; end;
		295	+ class CustomBlock9 < Block; end;
		296	+
		297	+ class TestBlockPlugin < Noosfero::Plugin
		298	+ def self.extra_blocks
		299	+ {
		300	+ CustomBlock1 => {:type => Environment, :position => [1]},
		301	+ CustomBlock2 => {:type => Environment, :position => 1},
		302	+ CustomBlock3 => {:type => Environment, :position => '1'},
		303	+ CustomBlock4 => {:type => Environment, :position => [2]},
		304	+ CustomBlock5 => {:type => Environment, :position => 2},
		305	+ CustomBlock6 => {:type => Environment, :position => '2'},
		306	+ CustomBlock7 => {:type => Environment, :position => [3]},
		307	+ CustomBlock8 => {:type => Environment, :position => 3},
		308	+ CustomBlock9 => {:type => Environment, :position => '3'},
		309	+ }
		310	+ end
		311	+ end
		312	+
		313	+ Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([TestBlockPlugin.new])
		314	+ login_as(create_admin_user(Environment.default))
		315	+ get :add_block
		316	+ assert_response :success
		317	+
		318	+ assert !@controller.instance_variable_get('@side_block_types').include?(CustomBlock1)
		319	+ assert !@controller.instance_variable_get('@side_block_types').include?(CustomBlock2)
		320	+ assert !@controller.instance_variable_get('@side_block_types').include?(CustomBlock3)
		321	+ assert @controller.instance_variable_get('@side_block_types').include?(CustomBlock4)
		322	+ assert @controller.instance_variable_get('@side_block_types').include?(CustomBlock5)
		323	+ assert @controller.instance_variable_get('@side_block_types').include?(CustomBlock6)
		324	+ assert @controller.instance_variable_get('@side_block_types').include?(CustomBlock7)
		325	+ assert @controller.instance_variable_get('@side_block_types').include?(CustomBlock8)
		326	+ assert @controller.instance_variable_get('@side_block_types').include?(CustomBlock9)
		327	+ end
		328	+
		329	+ should 'a block plugin cannot be listed for unspecified types' do
		330	+ class CustomBlock1 < Block; end;
		331	+ class CustomBlock2 < Block; end;
		332	+ class CustomBlock3 < Block; end;
		333	+ class CustomBlock4 < Block; end;
		334	+ class CustomBlock5 < Block; end;
		335	+ class CustomBlock6 < Block; end;
		336	+ class CustomBlock7 < Block; end;
		337	+ class CustomBlock8 < Block; end;
		338	+
		339	+ class TestBlockPlugin < Noosfero::Plugin
		340	+ def self.extra_blocks
		341	+ {
		342	+ CustomBlock1 => {:type => Person, :position => 1},
		343	+ CustomBlock2 => {:type => Community, :position => 1},
		344	+ CustomBlock3 => {:type => Enterprise, :position => 1},
		345	+ CustomBlock4 => {:type => Environment, :position => 1},
		346	+ CustomBlock5 => {:type => Person, :position => 2},
		347	+ CustomBlock6 => {:type => Community, :position => 3},
		348	+ CustomBlock7 => {:type => Enterprise, :position => 2},
		349	+ CustomBlock8 => {:type => Environment, :position => 3},
		350	+ }
		351	+ end
		352	+ end
		353	+
		354	+ Noosfero::Plugin::Manager.any_instance.stubs(:enabled_plugins).returns([TestBlockPlugin.new])
		355	+ login_as(create_admin_user(Environment.default))
		356	+ get :add_block
		357	+ assert_response :success
		358	+
		359	+ assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock1)
		360	+ assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock2)
		361	+ assert !@controller.instance_variable_get('@center_block_types').include?(CustomBlock3)
		362	+ assert @controller.instance_variable_get('@center_block_types').include?(CustomBlock4)
		363	+ assert !@controller.instance_variable_get('@side_block_types').include?(CustomBlock5)
		364	+ assert !@controller.instance_variable_get('@side_block_types').include?(CustomBlock6)
		365	+ assert !@controller.instance_variable_get('@side_block_types').include?(CustomBlock7)
		366	+ assert @controller.instance_variable_get('@side_block_types').include?(CustomBlock8)
		367	+ end
		368	+
202	end	369	end
	@@ -26,4 +26,476 @@ class PluginTest < ActiveSupport::TestCase		@@ -26,4 +26,476 @@ class PluginTest < ActiveSupport::TestCase
26	assert_equal({:controller => 'plugin_test/plugin1_admin', :action => 'index'}, Plugin1.admin_url)	26	assert_equal({:controller => 'plugin_test/plugin1_admin', :action => 'index'}, Plugin1.admin_url)
27	end	27	end
28		28
		29	+ should 'returns empty hash for class method extra_blocks by default if no blocks are defined on plugin' do
		30	+
		31	+ class SomePlugin1 < Noosfero::Plugin
		32	+ end
		33	+
		34	+ assert_equal({}, SomePlugin1.extra_blocks)
		35	+ end
		36	+
		37	+ should 'returns empty array for instance method extra_blocks by default if no blocks are defined on plugin' do
		38	+ class Plugin1 < Noosfero::Plugin
		39	+ def self.extra_blocks
		40	+ end
		41	+ end
		42	+ p = Plugin1.new
		43	+ assert_equal([], p.extra_blocks)
		44	+ end
		45	+
		46	+ should 'returns empty array for instance method extra_blocks by default if nil is returned' do
		47	+ class Plugin1 < Noosfero::Plugin
		48	+ def self.extra_blocks
		49	+ nil
		50	+ end
		51	+ end
		52	+ p = Plugin1.new
		53	+ assert_equal([], p.extra_blocks)
		54	+ end
		55	+
		56	+ should 'returns the blocks implemented by plugin' do
		57	+ class CustomBlock1 < Block; end;
		58	+ class CustomBlock2 < Block; end;
		59	+
		60	+ class Plugin1 < Noosfero::Plugin
		61	+ def self.extra_blocks
		62	+ {
		63	+ CustomBlock1 => {},
		64	+ CustomBlock2 => {}
		65	+ }
		66	+ end
		67	+ end
		68	+ p = Plugin1.new
		69	+ assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks)
		70	+ assert_equal([], p.extra_blocks - [CustomBlock1, CustomBlock2])
		71	+ end
		72	+
		73	+ should 'returns only person block and non defined types block if type person is specified' do
		74	+ class CustomBlock1 < Block; end;
		75	+ class CustomBlock2 < Block; end;
		76	+ class CustomBlock3 < Block; end;
		77	+ class CustomBlock4 < Block; end;
		78	+ class CustomBlock5 < Block; end;
		79	+
		80	+ class Plugin1 < Noosfero::Plugin
		81	+ def self.extra_blocks
		82	+ {
		83	+ CustomBlock1 => {:type => 'person'},
		84	+ CustomBlock2 => {},
		85	+ CustomBlock3 => {:type => 'enterprise'},
		86	+ CustomBlock4 => {:type => 'community'},
		87	+ CustomBlock5 => {:type => 'environment'},
		88	+ }
		89	+ end
		90	+ end
		91	+ p = Plugin1.new
		92	+ assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:type => Person))
		93	+ assert_equal([], p.extra_blocks(:type => Person) - [CustomBlock1, CustomBlock2])
		94	+ end
		95	+
		96	+ should 'returns only community block and non defined types block if type community is specified' do
		97	+ class CustomBlock1 < Block; end;
		98	+ class CustomBlock2 < Block; end;
		99	+ class CustomBlock3 < Block; end;
		100	+ class CustomBlock4 < Block; end;
		101	+ class CustomBlock5 < Block; end;
		102	+
		103	+ class Plugin1 < Noosfero::Plugin
		104	+ def self.extra_blocks
		105	+ {
		106	+ CustomBlock1 => {:type => 'community'},
		107	+ CustomBlock2 => {},
		108	+ CustomBlock3 => {:type => 'person'},
		109	+ CustomBlock4 => {:type => 'enterprise'},
		110	+ CustomBlock5 => {:type => 'environment'},
		111	+ }
		112	+ end
		113	+ end
		114	+ p = Plugin1.new
		115	+ assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:type => Community))
		116	+ assert_equal([], p.extra_blocks(:type => Community) - [CustomBlock1, CustomBlock2])
		117	+ end
		118	+
		119	+ should 'returns only enterprise block and non defined types block if type enterprise is specified' do
		120	+ class CustomBlock1 < Block; end;
		121	+ class CustomBlock2 < Block; end;
		122	+ class CustomBlock3 < Block; end;
		123	+ class CustomBlock4 < Block; end;
		124	+ class CustomBlock5 < Block; end;
		125	+
		126	+ class Plugin1 < Noosfero::Plugin
		127	+ def self.extra_blocks
		128	+ {
		129	+ CustomBlock1 => {:type => 'enterprise'},
		130	+ CustomBlock2 => {},
		131	+ CustomBlock3 => {:type => 'person'},
		132	+ CustomBlock4 => {:type => 'community'},
		133	+ CustomBlock5 => {:type => 'environment'},
		134	+ }
		135	+ end
		136	+ end
		137	+ p = Plugin1.new
		138	+ assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:type => Enterprise))
		139	+ assert_equal([], p.extra_blocks(:type => Enterprise) - [CustomBlock1, CustomBlock2])
		140	+ end
		141	+
		142	+ should 'returns only environment block and non defined types block if type environment is specified' do
		143	+ class CustomBlock1 < Block; end;
		144	+ class CustomBlock2 < Block; end;
		145	+ class CustomBlock3 < Block; end;
		146	+ class CustomBlock4 < Block; end;
		147	+ class CustomBlock5 < Block; end;
		148	+
		149	+ class Plugin1 < Noosfero::Plugin
		150	+ def self.extra_blocks
		151	+ {
		152	+ CustomBlock1 => {:type => 'environment'},
		153	+ CustomBlock2 => {},
		154	+ CustomBlock3 => {:type => 'enterprise'},
		155	+ CustomBlock4 => {:type => 'community'},
		156	+ CustomBlock5 => {:type => 'person'},
		157	+ }
		158	+ end
		159	+ end
		160	+ p = Plugin1.new
		161	+ assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:type => Environment))
		162	+ assert_equal([], p.extra_blocks(:type => Environment) - [CustomBlock1, CustomBlock2])
		163	+ end
		164	+
		165	+ should 'returns array of blocks of a specified type' do
		166	+ class CustomBlock1 < Block; end;
		167	+ class CustomBlock2 < Block; end;
		168	+ class CustomBlock3 < Block; end;
		169	+ class CustomBlock4 < Block; end;
		170	+ class CustomBlock5 < Block; end;
		171	+
		172	+ class Plugin1 < Noosfero::Plugin
		173	+ def self.extra_blocks
		174	+ {
		175	+ CustomBlock1 => {:type => 'person'},
		176	+ CustomBlock2 => {:type => 'person'},
		177	+ CustomBlock3 => {:type => 'environment'},
		178	+ CustomBlock4 => {:type => 'enterprise'},
		179	+ CustomBlock5 => {:type => 'community'},
		180	+ }
		181	+ end
		182	+ end
		183	+ p = Plugin1.new
		184	+ assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:type => Person))
		185	+ assert_equal([], p.extra_blocks(:type => Person) - [CustomBlock1, CustomBlock2])
		186	+ end
		187	+
		188	+ should 'returns all blocks without type if no type is specified' do
		189	+ class CustomBlock1 < Block; end;
		190	+ class CustomBlock2 < Block; end;
		191	+ class CustomBlock3 < Block; end;
		192	+ class CustomBlock4 < Block; end;
		193	+ class CustomBlock5 < Block; end;
		194	+ class CustomBlock6 < Block; end;
		195	+
		196	+ class Plugin1 < Noosfero::Plugin
		197	+ def self.extra_blocks
		198	+ {
		199	+ CustomBlock1 => {:type => 'person'},
		200	+ CustomBlock2 => {:type => 'environment'},
		201	+ CustomBlock3 => {:type => 'enterprise'},
		202	+ CustomBlock4 => {:type => 'community'},
		203	+ CustomBlock5 => {},
		204	+ CustomBlock6 => {},
		205	+ }
		206	+ end
		207	+ end
		208	+ p = Plugin1.new
		209	+ assert_equal([], [CustomBlock5, CustomBlock6] - p.extra_blocks)
		210	+ assert_equal([], p.extra_blocks - [CustomBlock5, CustomBlock6])
		211	+ end
		212	+
		213	+ should 'returns all blocks if type all is specified as parameter' do
		214	+ class CustomBlock1 < Block; end;
		215	+ class CustomBlock2 < Block; end;
		216	+ class CustomBlock3 < Block; end;
		217	+ class CustomBlock4 < Block; end;
		218	+ class CustomBlock5 < Block; end;
		219	+ class CustomBlock6 < Block; end;
		220	+
		221	+ class Plugin1 < Noosfero::Plugin
		222	+ def self.extra_blocks
		223	+ {
		224	+ CustomBlock1 => {:type => 'person'},
		225	+ CustomBlock2 => {:type => 'environment'},
		226	+ CustomBlock3 => {:type => 'enterprise'},
		227	+ CustomBlock4 => {:type => 'community'},
		228	+ CustomBlock5 => {},
		229	+ CustomBlock6 => {},
		230	+ }
		231	+ end
		232	+ end
		233	+ p = Plugin1.new
		234	+ assert_equal([], [CustomBlock1, CustomBlock2, CustomBlock3, CustomBlock4, CustomBlock5, CustomBlock6] - p.extra_blocks(:type => :all))
		235	+ assert_equal([], p.extra_blocks(:type => :all) - [CustomBlock1, CustomBlock2, CustomBlock3, CustomBlock4, CustomBlock5, CustomBlock6])
		236	+ end
		237	+
		238	+
		239	+ should 'returns blocks of specified types' do
		240	+ class CustomBlock1 < Block; end;
		241	+ class CustomBlock2 < Block; end;
		242	+ class CustomBlock3 < Block; end;
		243	+ class CustomBlock4 < Block; end;
		244	+
		245	+ class Plugin1 < Noosfero::Plugin
		246	+ def self.extra_blocks
		247	+ {
		248	+ CustomBlock1 => {:type => ['person', 'environment']},
		249	+ CustomBlock2 => {:type => 'environment'},
		250	+ CustomBlock3 => {:type => 'enterprise'},
		251	+ CustomBlock4 => {:type => 'community'},
		252	+ }
		253	+ end
		254	+ end
		255	+ p = Plugin1.new
		256	+ assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:type => Environment))
		257	+ assert_equal([], p.extra_blocks(:type => Environment) - [CustomBlock1, CustomBlock2])
		258	+ end
		259	+
		260	+ should 'returns blocks of with types passed as string or constant' do
		261	+ class CustomBlock1 < Block; end;
		262	+ class CustomBlock2 < Block; end;
		263	+ class CustomBlock3 < Block; end;
		264	+ class CustomBlock4 < Block; end;
		265	+ class CustomBlock5 < Block; end;
		266	+
		267	+ class Plugin1 < Noosfero::Plugin
		268	+ def self.extra_blocks
		269	+ {
		270	+ CustomBlock1 => {:type => ['person', 'environment']},
		271	+ CustomBlock2 => {:type => 'environment'},
		272	+ CustomBlock3 => {:type => Environment},
		273	+ CustomBlock4 => {:type => [Environment]},
		274	+ CustomBlock5 => {:type => 'person'},
		275	+ }
		276	+ end
		277	+ end
		278	+ p = Plugin1.new
		279	+ assert_equal([], [CustomBlock1, CustomBlock2, CustomBlock3, CustomBlock4] - p.extra_blocks(:type => Environment))
		280	+ assert_equal([], p.extra_blocks(:type => Environment) - [CustomBlock1, CustomBlock2, CustomBlock3, CustomBlock4])
		281	+ end
		282	+
		283	+ should 'through exception if undefined type is specified as parameter' do
		284	+ class CustomBlock1 < Block; end;
		285	+
		286	+ class Plugin1 < Noosfero::Plugin
		287	+ def self.extra_blocks
		288	+ {
		289	+ CustomBlock1 => {:type => 'undefined_type'},
		290	+ }
		291	+ end
		292	+ end
		293	+ p = Plugin1.new
		294	+
		295	+ assert_raise NameError do
		296	+ p.extra_blocks
		297	+ end
		298	+ end
		299	+
		300	+ should 'returns only position 1 block and non defined position block if position 1 is specified' do
		301	+ class CustomBlock1 < Block; end;
		302	+ class CustomBlock2 < Block; end;
		303	+ class CustomBlock3 < Block; end;
		304	+ class CustomBlock4 < Block; end;
		305	+
		306	+ class Plugin1 < Noosfero::Plugin
		307	+ def self.extra_blocks
		308	+ {
		309	+ CustomBlock1 => {:position => 1},
		310	+ CustomBlock2 => {},
		311	+ CustomBlock3 => {:position => 3},
		312	+ CustomBlock4 => {:position => 2},
		313	+ }
		314	+ end
		315	+ end
		316	+ p = Plugin1.new
		317	+ assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:position => 1))
		318	+ assert_equal([], p.extra_blocks(:position => 1) - [CustomBlock1, CustomBlock2])
		319	+ end
		320	+
		321	+ should 'returns only position 2 block and non defined position block if position 2 is specified' do
		322	+ class CustomBlock1 < Block; end;
		323	+ class CustomBlock2 < Block; end;
		324	+ class CustomBlock3 < Block; end;
		325	+ class CustomBlock4 < Block; end;
		326	+
		327	+ class Plugin1 < Noosfero::Plugin
		328	+ def self.extra_blocks
		329	+ {
		330	+ CustomBlock1 => {:position => 2},
		331	+ CustomBlock2 => {},
		332	+ CustomBlock3 => {:position => 3},
		333	+ CustomBlock4 => {:position => 1},
		334	+ }
		335	+ end
		336	+ end
		337	+ p = Plugin1.new
		338	+ assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:position => 2))
		339	+ assert_equal([], p.extra_blocks(:position => 2) - [CustomBlock1, CustomBlock2])
		340	+ end
		341	+
		342	+ should 'returns only position 3 block and non defined position block if position 3 is specified' do
		343	+ class CustomBlock1 < Block; end;
		344	+ class CustomBlock2 < Block; end;
		345	+ class CustomBlock3 < Block; end;
		346	+ class CustomBlock4 < Block; end;
		347	+
		348	+ class Plugin1 < Noosfero::Plugin
		349	+ def self.extra_blocks
		350	+ {
		351	+ CustomBlock1 => {:position => 3},
		352	+ CustomBlock2 => {},
		353	+ CustomBlock3 => {:position => 1},
		354	+ CustomBlock4 => {:position => 2},
		355	+ }
		356	+ end
		357	+ end
		358	+ p = Plugin1.new
		359	+ assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:position => 3))
		360	+ assert_equal([], p.extra_blocks(:position => 3) - [CustomBlock1, CustomBlock2])
		361	+ end
		362	+
		363	+ should 'returns array of blocks of a specified position' do
		364	+ class CustomBlock1 < Block; end;
		365	+ class CustomBlock2 < Block; end;
		366	+ class CustomBlock3 < Block; end;
		367	+ class CustomBlock4 < Block; end;
		368	+
		369	+ class Plugin1 < Noosfero::Plugin
		370	+ def self.extra_blocks
		371	+ {
		372	+ CustomBlock1 => {:position => 1 },
		373	+ CustomBlock2 => {:position => 1 },
		374	+ CustomBlock3 => {:position => 2},
		375	+ CustomBlock4 => {:position => 3},
		376	+ }
		377	+ end
		378	+ end
		379	+ p = Plugin1.new
		380	+ assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:position => 1))
		381	+ assert_equal([], p.extra_blocks(:position => 1) - [CustomBlock1, CustomBlock2])
		382	+ end
		383	+
		384	+ should 'returns array of blocks of a specified position wihout any type' do
		385	+ class CustomBlock1 < Block; end;
		386	+ class CustomBlock2 < Block; end;
		387	+ class CustomBlock3 < Block; end;
		388	+ class CustomBlock4 < Block; end;
		389	+ class CustomBlock5 < Block; end;
		390	+ class CustomBlock6 < Block; end;
		391	+ class CustomBlock7 < Block; end;
		392	+ class CustomBlock8 < Block; end;
		393	+ class CustomBlock9 < Block; end;
		394	+ class CustomBlock10 < Block; end;
		395	+
		396	+ class Plugin1 < Noosfero::Plugin
		397	+ def self.extra_blocks
		398	+ {
		399	+ CustomBlock1 => {:type => Person, :position => 1 },
		400	+ CustomBlock2 => {:type => Community, :position => 1 },
		401	+ CustomBlock3 => {:type => Enterprise, :position => 1 },
		402	+ CustomBlock4 => {:type => Environment, :position => 1 },
		403	+ CustomBlock5 => {:position => 1 },
		404	+ CustomBlock6 => {:type => Person, :position => [1,2,3] },
		405	+ CustomBlock7 => {:type => Community, :position => [1,2,3] },
		406	+ CustomBlock8 => {:type => Enterprise, :position => [1,2,3] },
		407	+ CustomBlock9 => {:type => Environment, :position => [1,2,3] },
		408	+ CustomBlock10 => {:position => [1,2,3] },
		409	+ }
		410	+ end
		411	+ end
		412	+ p = Plugin1.new
		413	+ assert_equal([], [CustomBlock5, CustomBlock10] - p.extra_blocks(:position => 1))
		414	+ assert_equal([], p.extra_blocks(:position => 1) - [CustomBlock5, CustomBlock10])
		415	+ end
		416	+
		417	+ should 'returns blocks of all position if no position is specified' do
		418	+ class CustomBlock1 < Block; end;
		419	+ class CustomBlock2 < Block; end;
		420	+ class CustomBlock3 < Block; end;
		421	+ class CustomBlock4 < Block; end;
		422	+
		423	+ class Plugin1 < Noosfero::Plugin
		424	+ def self.extra_blocks
		425	+ {
		426	+ CustomBlock1 => {:position => 1 },
		427	+ CustomBlock2 => {:position => 2},
		428	+ CustomBlock3 => {:position => 3},
		429	+ CustomBlock4 => {},
		430	+ }
		431	+ end
		432	+ end
		433	+ p = Plugin1.new
		434	+ assert_equal([], [CustomBlock1, CustomBlock2, CustomBlock3, CustomBlock4] - p.extra_blocks)
		435	+ assert_equal([], p.extra_blocks - [CustomBlock1, CustomBlock2, CustomBlock3, CustomBlock4])
		436	+ end
		437	+
		438	+ should 'returns blocks of specified positions' do
		439	+ class CustomBlock1 < Block; end;
		440	+ class CustomBlock2 < Block; end;
		441	+ class CustomBlock3 < Block; end;
		442	+
		443	+ class Plugin1 < Noosfero::Plugin
		444	+ def self.extra_blocks
		445	+ {
		446	+ CustomBlock1 => {:position => [1, 2]},
		447	+ CustomBlock2 => {:position => 2},
		448	+ CustomBlock3 => {:position => 3},
		449	+ }
		450	+ end
		451	+ end
		452	+ p = Plugin1.new
		453	+ assert_equal([], [CustomBlock1, CustomBlock2] - p.extra_blocks(:position => 2))
		454	+ assert_equal([], p.extra_blocks(:position => 2) - [CustomBlock1, CustomBlock2])
		455	+ end
		456	+
		457	+ should 'returns blocks of with positions passed as string or numbers' do
		458	+ class CustomBlock1 < Block; end;
		459	+ class CustomBlock2 < Block; end;
		460	+ class CustomBlock3 < Block; end;
		461	+ class CustomBlock4 < Block; end;
		462	+ class CustomBlock5 < Block; end;
		463	+
		464	+ class Plugin1 < Noosfero::Plugin
		465	+ def self.extra_blocks
		466	+ {
		467	+ CustomBlock1 => {:position => [1, '2']},
		468	+ CustomBlock2 => {:position => '2'},
		469	+ CustomBlock3 => {:position => 2},
		470	+ CustomBlock4 => {:position => [2]},
		471	+ CustomBlock5 => {:position => '1'},
		472	+ }
		473	+ end
		474	+ end
		475	+ p = Plugin1.new
		476	+ assert_equal([], [CustomBlock1, CustomBlock2, CustomBlock3, CustomBlock4] - p.extra_blocks(:position => 2))
		477	+ assert_equal([], p.extra_blocks(:position => 2) - [CustomBlock1, CustomBlock2, CustomBlock3, CustomBlock4])
		478	+ end
		479	+
		480	+ should 'through exception if undefined position is specified as parameter' do
		481	+ class CustomBlock1 < Block; end;
		482	+
		483	+ class Plugin1 < Noosfero::Plugin
		484	+ def self.extra_blocks
		485	+ {
		486	+ CustomBlock1 => {:type => 'undefined_type'},
		487	+ }
		488	+ end
		489	+ end
		490	+ p = Plugin1.new
		491	+
		492	+ assert_raise NameError do
		493	+ p.extra_blocks
		494	+ end
		495	+ end
		496	+
		497	+
		498	+
		499	+
		500	+
29	end	501	end