goldberg_generator 0.2.2

data/templates/vendor/plugins/goldberg/test/test_helper.rb

@@ -0,0 +1,40 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.dirname(__FILE__) +
+                         "/../../../../config/environment")
+
+require 'test_help'
+
+class Test::Unit::TestCase
+  # Transactional fixtures accelerate your tests by wrapping each test method
+  # in a transaction that's rolled back on completion.  This ensures that the
+  # test database remains unchanged so your fixtures don't have to be reloaded
+  # between every test method.  Fewer database queries means faster tests.
+  #
+  # Read Mike Clark's excellent walkthrough at
+  #   http://clarkware.com/cgi/blosxom/2005/10/24#Rails10FastTesting
+  #
+  # Every Active Record database supports transactions except MyISAM tables
+  # in MySQL.  Turn off transactional fixtures in this case; however, if you
+  # don't care one way or the other, switching from MyISAM to InnoDB tables
+  # is recommended.
+  #
+  # The only drawback to using transactional fixtures is when you actually 
+  # need to test transactions.  Since your test is bracketed by a transaction,
+  # any transactions started in your code will be automatically rolled back.
+  self.use_transactional_fixtures = true
+
+  # Instantiated fixtures are slow, but give you @david where otherwise you
+  # would need people(:david).  If you don't want to migrate your existing
+  # test cases which use the @david style and don't mind the speed hit (each
+  # instantiated fixtures translates to a database query per test method),
+  # then set this back to true.
+  self.use_instantiated_fixtures  = false
+
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  # fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end

data/templates/vendor/plugins/goldberg/test/unit/content_page_test.rb

@@ -0,0 +1,87 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ContentPageTest < Test::Unit::TestCase
+  include Goldberg::TestHelper
+
+  def setup
+    @permission = Goldberg::Permission.find :first
+  end
+
+  def test_all_fields
+    page = Goldberg::ContentPage.new(:name => 'test', :title => 'A test')
+    page.permission = @permission
+    page.markup_style = 'Raw HTML'
+    page.content = 'This is a test'
+    assert page.save
+  end
+
+  # Test that HTML content is generated when it's accessed
+  def test_content_cached_on_access
+    page = new_page()
+    page.content = 'This is a test'
+    # No content yet
+    assert_nil page.content_cache
+    # Calling #content_html triggers HTML generation
+    assert_not_nil page.content_html
+    assert_not_nil page.content_cache
+  end
+
+  # Test that HTML content is generated when the page is saved
+  def test_content_cached_on_save
+    page = new_page()
+    page.content = 'This is a test'
+    # No content yet
+    assert_nil page.content_cache
+    page.save
+    # Saving triggers HTML generation
+    assert_not_nil page.content_cache
+  end
+
+  def test_minimal_fields
+    page = Goldberg::ContentPage.new(:name => 'test', :title => 'A test')
+    page.permission = @permission
+    assert page.save
+  end
+
+  def test_no_fields
+    page = Goldberg::ContentPage.new
+    assert !page.valid?
+    # name, title and permission_id are compulsory
+    [:name, :title, :permission_id].each do |attr|
+      assert page.errors.on(attr)
+    end
+  end
+
+  # Test that name is unique
+  def test_uniqueness_of
+    # Create a page named 'test' and save it
+    page1 = new_page()
+    assert page1.save
+
+    # Duplicate page name won't work
+    page2 = new_page()
+    assert !page2.save
+    assert page2.errors.on(:name)
+
+    # Fix name and it should work
+    page2.name = 'test2'
+    assert page2.save
+  end
+
+  # Test that the URL generated for the page equals the name preceded
+  # with a slash
+  def test_url_generation
+    page = new_page()
+    assert_equal page.url, '/test'
+  end
+
+    
+  protected
+
+  def new_page
+    page = Goldberg::ContentPage.new(:name => 'test',
+                                     :title => 'This is a test')
+    page.permission = @permission
+    return page
+  end
+end

data/templates/vendor/plugins/goldberg/test/unit/controller_action_test.rb

@@ -0,0 +1,85 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ControllerActionTest < Test::Unit::TestCase
+  include Goldberg::TestHelper
+
+  def setup
+    # Some associated records (two of each will do)
+    (@sc1, @sc2) = Goldberg::SiteController.find :all
+    (@p1, @p2) = Goldberg::Permission.find :all
+  end
+  
+  def test_no_fields
+    ca = Goldberg::ControllerAction.new
+    assert !ca.valid?
+    # name, and site_controller_id are compulsory
+    [:name, :site_controller_id].each do |attr|
+      assert ca.errors.on(attr)
+    end
+  end
+
+  def test_minimal_fields
+    ca = Goldberg::ControllerAction.new(:name => 'test')
+    ca.site_controller = @sc1
+    assert ca.save
+    
+    # All fields
+    ca.permission = @p1
+    assert ca.save
+  end
+
+  def test_all_fields
+    ca = Goldberg::ControllerAction.new(:name => 'test')
+    ca.site_controller = @sc1
+    ca.permission = @p1
+    assert ca.save
+  end    
+  
+  # The name of the controller action should be unique within the
+  # scope of the site controller.
+  def test_name_unique_within_scope_of_site_controller
+    ca1 = Goldberg::ControllerAction.new(:name => 'test')
+    ca2 = Goldberg::ControllerAction.new(:name => 'test')
+    ca1.site_controller = @sc1
+    ca2.site_controller = @sc1
+    ca1.save
+
+    # Error: name not unique within scope of controller
+    assert !ca2.save
+    assert ca2.errors.on(:name)
+
+    # Should work: same name, different controllers
+    ca2.site_controller = @sc2
+    assert ca2.save
+
+    # Should work: different names, same controller
+    ca2.name = 'test2'
+    ca2.site_controller = @sc1
+    assert ca2.save
+  end
+
+  # The effective permission is the permission of the controller
+  # action, if specified; otherwise it is the permission of the
+  # action's site controller.
+  def test_effective_permission
+    # Make sure we know the permission on the site controller
+    @sc1.permission = @p1
+    @sc1.save!
+    
+    ca = Goldberg::ControllerAction.new(:name => 'test')
+    ca.site_controller = @sc1
+    ca.save!
+
+    # No explicit permission: effective permission should be the same
+    # as site controller
+    assert_nil ca.permission
+    assert_equal @p1.id, ca.effective_permission.id
+
+    # Explicit permission: should override permission of site
+    # controller
+    ca.permission = @p2
+    ca.save!
+    assert_not_nil ca.permission
+    assert_equal @p2.id, ca.effective_permission.id
+  end
+end

data/templates/vendor/plugins/goldberg/test/unit/menu_item_test.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class MenuItemTest < Test::Unit::TestCase
+  include Goldberg::TestHelper
+  
+  def test_name_is_unique
+    name_1 = 'THIS_IS_NAME_1'
+    name_2 = 'THIS_IS_NAME_2'
+    name_1.freeze
+    name_2.freeze
+
+    menu_item_1 = Goldberg::MenuItem.new(:content_page_id => 1)
+    menu_item_2 = Goldberg::MenuItem.new(:content_page_id => 1)
+
+    menu_item_1.name = name_1
+    menu_item_1.label = 'This is name 1'
+    menu_item_2.name = name_2
+    menu_item_2.label = 'This is name 2'
+
+    assert(menu_item_1.save)
+    assert(menu_item_2.save)
+
+    menu_item_2.name = name_1
+
+    assert(!menu_item_2.save)
+    assert(menu_item_2.errors.invalid?(:name))
+  end
+
+  
+  def test_name_is_required
+    mi = Goldberg::MenuItem.new(:content_page_id => 1)
+    assert(!mi.valid?)
+    assert(mi.errors.invalid?(:name))
+    assert(!mi.save)
+  end
+  
+  
+  def test_must_have_content_page_or_controller_action
+    mi = Goldberg::MenuItem.new(:name => 'test', :label => 'Test')
+    assert(!mi.valid?)
+    assert(mi.errors.invalid?(:content_page_id))
+    assert(mi.errors.invalid?(:controller_action_id))
+    assert(!mi.save)
+  end
+      
+end

data/templates/vendor/plugins/goldberg/test/unit/permission_test.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class PermissionTest < Test::Unit::TestCase
+  include Goldberg::TestHelper
+
+  def test_invalid_without_name
+    permission = Goldberg::Permission.new
+    assert(!permission.valid?)
+    assert(permission.errors.invalid?(:name))
+    assert(!permission.save)
+  end
+
+
+  def test_uniqueness_of_name
+    name_1 = 'THIS_IS_NAME_1'
+    name_2 = 'THIS_IS_NAME_2'
+    name_1.freeze
+    name_2.freeze
+
+    permission_1 = Goldberg::Permission.new
+    permission_2 = Goldberg::Permission.new
+
+    permission_1.name = name_1
+    permission_2.name = name_2
+
+    assert(permission_1.save)
+    assert(permission_2.save)
+
+    permission_2.name = name_1
+
+    assert(!permission_2.save)
+    assert(permission_2.errors.invalid?(:name))
+  end
+
+end

data/templates/vendor/plugins/goldberg/test/unit/site_controller_test.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class SiteControllerTest < Test::Unit::TestCase
+  include Goldberg::TestHelper
+
+  def setup
+    @p = Goldberg::Permission.find :first
+  end
+  
+  def test_invalid_without_name
+    site_controller = Goldberg::SiteController.new
+    assert(!site_controller.valid?)
+    assert(site_controller.errors.invalid?(:name))
+    assert(!site_controller.save)
+  end
+
+
+  def test_uniqueness_of_name
+    name_1 = 'THIS_IS_NAME_1'
+    name_2 = 'THIS_IS_NAME_2'
+    name_1.freeze
+    name_2.freeze
+
+    site_controller_1 = Goldberg::SiteController.new
+    site_controller_1.permission = @p
+    site_controller_2 = Goldberg::SiteController.new
+    site_controller_2.permission = @p
+
+    site_controller_1.name = name_1
+    site_controller_2.name = name_2
+
+    assert(site_controller_1.save)
+    assert(site_controller_2.save)
+
+    site_controller_2.name = name_1
+
+    assert(!site_controller_2.save)
+    assert(site_controller_2.errors.invalid?(:name))
+  end
+
+  
+  #create so the classes method can be tested...
+  class ThereShouldBeNoSuchRealClassNameGoldbergTestController < ApplicationController
+  end
+  
+    
+  def test_classes_finds_direct_controller_derivatives
+    classes = Goldberg::SiteController.classes
+    assert(classes.has_value?(SiteControllerTest::ThereShouldBeNoSuchRealClassNameGoldbergTestController))
+  end
+
+  
+end

data/templates/vendor/plugins/goldberg/test/unit/system_settings_test.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class SystemSettingsTest < Test::Unit::TestCase
+  include Goldberg::TestHelper
+
+  def test_public_role
+    public_role = Goldberg::Role.find :first
+    ss = Goldberg::SystemSettings.create(:public_role_id => public_role.id)
+    assert_equal(public_role, ss.public_role)
+  end
+
+  def test_public_role_raises_when_role_not_found
+    ss = Goldberg::SystemSettings.create
+    assert_raise(ActiveRecord::RecordNotFound) {ss.public_role}
+  end
+
+  def test_site_default_page
+    page = Goldberg::ContentPage.find :first
+    ss = Goldberg::SystemSettings.create(:site_default_page_id => page.id)
+  end
+
+
+  def test_site_default_page_raises_when_page_not_found
+    ss = Goldberg::SystemSettings.create
+    assert_raise(ActiveRecord::RecordNotFound) {ss.site_default_page}
+  end
+
+
+  def test_not_found_page
+    page = Goldberg::ContentPage.find :first
+    ss = Goldberg::SystemSettings.create(:not_found_page_id => page.id)
+  end
+
+
+  def test_not_found_page_raises_when_page_not_found
+    ss = Goldberg::SystemSettings.create
+    assert_raise(ActiveRecord::RecordNotFound) {ss.not_found_page}
+  end
+
+
+  def test_permission_denied_page
+    page = Goldberg::ContentPage.find :first
+    ss = Goldberg::SystemSettings.create(:permission_denied_page_id => page.id)
+  end
+
+
+  def test_permission_denied_page_raises_when_page_permission_denied
+    ss = Goldberg::SystemSettings.create
+    assert_raise(ActiveRecord::RecordNotFound) {ss.permission_denied_page}
+  end
+
+
+  def test_session_expired_page
+    page = Goldberg::ContentPage.find :first
+    ss = Goldberg::SystemSettings.create(:session_expired_page_id => page.id)
+  end
+
+
+  def test_session_expired_page_raises_when_page_session_expired
+    ss = Goldberg::SystemSettings.create
+    assert_raise(ActiveRecord::RecordNotFound) {ss.session_expired_page}
+  end
+
+
+  def test_system_pages_returns_nil_when_tested_page_not_system_page
+    ss = Goldberg::SystemSettings.create
+    page = Goldberg::ContentPage.find :first
+    assert_nil(ss.system_pages(page.id))
+  end
+
+end

data/templates/vendor/plugins/goldberg/test/unit/user_test.rb

@@ -0,0 +1,104 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class UserTest < Test::Unit::TestCase
+  include Goldberg::TestHelper
+
+  def setup
+    @role = Goldberg::Role.find :first
+  end
+  
+  def test_requires_name
+    user = Goldberg::User.new
+    assert(!user.valid?)
+    assert(user.errors.invalid?(:name))
+    assert(!user.save)
+  end
+  
+  
+  def test_name_unique
+    name_1 = 'NAME1'
+    name_2 = 'NAME2'
+    name_1.freeze
+    name_2.freeze
+    
+    user_1 = Goldberg::User.new(:name => name_1)
+    user_1.role = @role
+    user_1.clear_password = 'fred'
+    user_2 = Goldberg::User.new(:name => name_2)
+    user_2.role = @role
+    user_2.clear_password = 'fred'
+    
+    assert(user_1.save)
+    assert(user_2.save)
+    
+    user_2.name = name_1
+    assert(!user_2.save)
+    assert(!user_2.valid?)
+    assert(user_2.errors.invalid?(:name))
+  end
+  
+  
+  def test_password_updated_on_save_when_clear_password_set
+    user = Goldberg::User.new(:name => 'name')
+    user.role = @role
+    user.clear_password = 'fred'
+    assert(user.save)
+    
+    saved_password = user.password
+    saved_salt = user.password_salt
+    
+    user.clear_password = 'test123'
+    assert(user.save)
+    
+    assert_not_equal(saved_password, user.password)
+    assert_not_equal(saved_salt, user.password_salt)
+    
+    saved_password = user.password
+    saved_salt = user.password_salt
+    
+    user.name = 'haha'
+    assert(user.name)
+    
+    assert_equal(saved_password, user.password)
+    assert_equal(saved_salt, user.password_salt)
+  end
+  
+  
+  def test_clear_password_set_nil_on_save
+    new_pass = 'test123'
+    new_pass.freeze
+    
+    user = Goldberg::User.new(:name => 'name')
+    user.role = @role
+    assert(!user.save)
+    
+    user.clear_password = new_pass
+    assert_equal(new_pass, user.clear_password)
+    assert(user.save)
+    assert_nil(user.clear_password)
+  end
+  
+  
+  def test_check_password
+    first_pass = 'test'
+    new_pass = 'test1'    
+    first_pass.freeze
+    new_pass.freeze
+    
+    assert_not_equal(first_pass, new_pass)
+    
+    user = Goldberg::User.new(:name => 'user')
+    user.role =  @role
+    user.clear_password = first_pass
+    assert(user.save)
+    
+    assert(user.check_password(first_pass))
+    assert(!user.check_password(new_pass))
+    
+    user.clear_password = new_pass
+    assert(user.save)
+    
+    assert(user.check_password(new_pass))
+    assert(!user.check_password(first_pass))
+  end
+end