parlement 0.1

data/test/functional/account_controller_test.rb

@@ -0,0 +1,239 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require_dependency 'account_controller'
+require 'breakpoint'
+
+# ADD to fix advance_by_days= problem
+require File.dirname(__FILE__) + '/../mocks/test/time'
+
+# Raise errors beyond the default web-based presentation
+class AccountController; def rescue_action(e) raise e end; end
+
+class AccountControllerTest < Test::Unit::TestCase
+
+	fixtures :people, LoginEngine.config(:user_table).to_sym
+
+	def setup
+		LoginEngine::CONFIG[:salt] = "test-salt"
+
+    @controller = AccountController.new
+    @request, @response = ActionController::TestRequest.new, ActionController::TestResponse.new
+    @request.host = "localhost"
+  end
+
+
+	"""                       _                     _       
+	 _ __  ___  ___ _   _  __| | ___     ___  _ __ | |_   _ 
+	| '_ \/ __|/ _ \ | | |/ _` |/ _ \   / _ \| '_ \| | | | |
+	| |_) \__ \  __/ |_| | (_| | (_) | | (_) | | | | | |_| |
+	| .__/|___/\___|\__,_|\__,_|\___/   \___/|_| |_|_|\__, |
+	|_|                                               |___/ 
+	"""
+	def test_signup
+    post :login, :person => { :name => "my_bob", :email => "" },
+			:user => { :password => "" }
+    assert_session_has :person
+    assert_session_has_no :user
+  end
+ 
+  def test_login_logoff_no_password
+    post :login, :person => { :name => "bob_other", :email => "" },
+			:user => { :password => "" }
+		assert_equal people(:bob_other), @request.session[:person]
+    assert_session_has_no :user
+    get :logout
+    assert_session_has_no :person
+  end
+
+  def test_bad_pseudo
+		post :login, :person => { :name => "yo", :email => "" },
+			:user => { :password => "" }
+    assert_invalid_column_on_record "person", :name
+    assert_success
+    assert_session_has_no :person
+  end
+
+
+	"""                                        _ 
+	 _ __   __ _ ___ _____      _____  _ __ __| |
+	| '_ \ / _` / __/ __\ \ /\ / / _ \| '__/ _` |
+	| |_) | (_| \__ \__ \\ V  V / (_) | | | (_| |
+	| .__/ \__,_|___/___/ \_/\_/ \___/|_|  \__,_|
+	|_|                                          
+	"""
+  def test_password_protect
+    post :login, :person => { :name => "bob_another", :email => "" },
+			:user => { :password => "atest" }
+    assert_session_has :person
+    assert_session_has :user
+  end
+ 
+  def test_auth_bob
+    post :login, :person => { :name => "bob", :email => "" },
+			:user => { :password => "atest" }
+    assert_equal people(:bob), @response.session[:person]
+    assert_session_has :person
+    assert_session_has :user
+  end
+
+  def test_bad_password
+    post :login, :person => { :name => "newbob", :email => "" },
+			:user => { :password => "newpassword", :password_confirmation => "wrong" }
+    assert_invalid_column_on_record "user", :password
+    assert_success
+  end
+
+  def test_login_logoff_password
+    post :login, :person => { :name => "my_bob", :email => "" },
+			:user => { :password => "my_bob" }
+    assert_session_has :person
+    get :logout
+    assert_session_has_no :person
+  end
+
+  def test_invalid_password
+    post :login, :person => { :name => "my_bob", :email => "" },
+			:user => { :password => "my_bob" }
+    assert_session_has :person
+    assert_session_has :user
+    get :logout
+    post :login, :person => { :name => "my_bob", :email => "" },
+			:user => { :password => "my_bo" }
+    assert_session_has_no :person
+    assert_session_has_no :user
+    #assert_template_has "login"
+  end
+
+
+	"""                   _ _ 
+		___ _ __ ___   __ _(_) |
+	 / _ \ '_ ` _ \ / _` | | |
+	|  __/ | | | | | (_| | | |
+	 \___|_| |_| |_|\__,_|_|_|
+	"""
+  def test_password_and_email_protect
+    post :login, :person => { :name => "my_bob", :email => "manu@noos.fr" },
+			:user => { :password => "my_bob" }
+    assert_session_has :person
+    assert_session_has :user
+		assert_equal "my_bob", @request.session[:person].name
+		assert_equal "manu@noos.fr", @request.session[:user].email
+		assert_not_equal @request.session[:person].email, @request.session[:user].email
+		assert_not_nil @request.session[:user].security_token
+  end
+ 
+  def invalid_email
+    post :login, :person => { :name => "bob", :email => "" },
+			:user => { :password => "not_correct" }
+
+    assert_session_has_no :person
+    assert_session_has_no :user
+    
+    assert_template_has "login"
+  end
+
+
+	def test_email_protect
+		LoginEngine::CONFIG[:use_email_notification] = true
+
+		ActionMailer::Base.deliveries = []
+
+		#@request.session['return-to'] = "/bogus/location"
+
+		assert_equal 5, User.count
+		post :login, :person => { :name => "newbob", :email => "newbob@test.com" },
+			:user => { :password => "newpassword" }
+		assert_session_has :person
+		assert_session_has :user
+		assert_equal 6, User.count
+
+		assert_equal 1, ActionMailer::Base.deliveries.size
+		mail = ActionMailer::Base.deliveries[0]
+		assert_equal "newbob@test.com", mail.to_addrs[0].to_s
+		assert_match /login:\s+\w+\n/, mail.encoded
+		assert_match /password:\s+\w+\n/, mail.encoded
+		mail.encoded =~ /key=(.*?)"/
+		key = $1
+
+		user = User.find_by_email("newbob@test.com")
+		person = Person.find_by_name(user.login)
+		assert_not_nil user
+		assert_not_nil person
+		assert_equal 1, user.verified
+		assert_not_equal user.email, person.email
+
+		# First past the expiration.
+		Time.advance_by_days = 1
+		get :check_key, :user=> { :id => "#{user.id}" }, :key => "#{key}"
+		Time.advance_by_days = 0
+		user = User.find_by_email("newbob@test.com")
+		person = Person.find_by_name(user.login)
+		assert_not_equal user.email, person.email
+
+		# Then a bogus key.
+		get :check_key, :user=> { :id => "#{user.id}" }, :key => "boguskey"
+		user = User.find_by_email("newbob@test.com")
+		person = Person.find_by_name(user.login) if user != nil
+		assert_not_equal user.email, person.email
+
+		# Now the real one.
+		get :check_key, :user=> { :id => "#{user.id}" }, :key => "#{key}"
+		user = User.find_by_email("newbob@test.com")
+		person = Person.find_by_name(user.login)
+		assert_equal user.email, person.email
+                                                                          
+		post :login, :person => { :name => "newbob", :email => "" },
+			:user => { :password => "newpassword" }
+		assert_session_has :person
+		assert_session_has :user
+		get :logout
+	end
+
+	def test_forgotten_password
+		LoginEngine::CONFIG[:use_email_notification] = true
+
+		ActionMailer::Base.deliveries = []
+
+		post :login, :person => { :name => "bob", :email => "bob@test.com" },
+			:user => { :password => "" }
+		assert_session_has_no :person
+		assert_session_has_no :user
+
+		assert_equal 1, ActionMailer::Base.deliveries.size
+		mail = ActionMailer::Base.deliveries[0]
+		assert_equal "bob@test.com", mail.to_addrs[0].to_s
+		mail.encoded =~ /key=(.*?)"/
+		key = $1
+
+		# First past the expiration.
+		Time.advance_by_days = 1
+		post :login, :person => { :name => "bob", :email => key },
+			:user => { :password => "newpassword" }
+		assert_session_has_no :person
+		assert_session_has_no :user
+		Time.advance_by_days = 0
+
+		# Then a bogus key.
+		post :login, :person => { :name => "bob", :email => "boguskey" },
+			:user => { :password => "newpassword" }
+		assert_session_has_no :person
+		assert_session_has_no :user
+
+		# Now the real one.
+		post :login, :person => { :name => "bob", :email => key },
+			:user => { :password => "newpassword" }
+		assert_session_has :person
+		assert_session_has :user
+		get :logout
+
+		post :login, :person => { :name => "bob", :email => "" },
+			:user => { :password => "password" }
+		assert_session_has_no :person
+		assert_session_has_no :user
+		post :login, :person => { :name => "bob", :email => "" },
+			:user => { :password => "newpassword" }
+		assert_session_has :person
+		assert_session_has :user
+		get :logout
+	end
+end
+

data/test/functional/elt_controller_test.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'elt_controller'
+
+# Re-raise errors caught by the controller.
+class EltController; def rescue_action(e) raise e end; end
+
+class EltControllerTest < Test::Unit::TestCase
+  def setup
+    @controller = EltController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+  end
+
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+end

data/test/mocks/test/time.rb

@@ -0,0 +1,17 @@
+require 'time'
+
+Time.class_eval { 
+  @@advance_by_days = 0
+  cattr_accessor :advance_by_days
+
+  class << Time
+    alias now_old now
+    def now
+      if Time.advance_by_days != 0
+        return Time.at(now_old.to_i + Time.advance_by_days * 60 * 60 * 24 + 1)
+      else
+        now_old
+      end
+    end
+  end
+}

data/test/mocks/test/user_notify.rb

@@ -0,0 +1,16 @@
+require 'models/user_notify.rb'
+
+ActionMailer::Base.class_eval {
+  @@inject_one_error = false
+  cattr_accessor :inject_one_error
+
+  private
+  def perform_delivery_test(mail)
+    if inject_one_error
+      ActionMailer::Base::inject_one_error = false
+      raise "Failed to send email" if raise_delivery_errors
+    else
+      deliveries << mail
+    end
+  end
+}

data/test/test_helper.rb

@@ -0,0 +1,28 @@
+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.
+  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
+
+  # Add more helper methods to be used by all tests here...
+end

data/test/unit/attachment_test.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class AttachmentTest < Test::Unit::TestCase
+  fixtures :elts, :attachments, :mails
+
+  def setup
+    @attachment = Attachment.find(0)
+  end
+
+  # Replace this with your real tests.
+  def test_truth
+    assert_kind_of Attachment,  @attachment
+  end
+end

data/test/unit/elt_test.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class EltTest < Test::Unit::TestCase
+  fixtures :elts, :attachments, :mails
+
+  def setup
+    @elt = Elt.find(1)
+  end
+
+  # Replace this with your real tests.
+  def test_truth
+    assert_kind_of Elt,  @elt
+  end
+end

data/test/unit/mail_test.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class MailTest < Test::Unit::TestCase
+  fixtures :elts, :mails, :attachments
+
+  def setup
+    @mail = Mail.find(1)
+  end
+
+  # Replace this with your real tests.
+  def test_truth
+    assert_kind_of Mail,  @mail
+  end
+end

data/test/unit/notifier_test.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'notifier'
+
+class NotifierTest < Test::Unit::TestCase
+  FIXTURES_PATH = File.dirname(__FILE__) + '/../fixtures'
+  CHARSET = "utf-8"
+
+  include ActionMailer::Quoting
+
+  def setup
+    ActionMailer::Base.delivery_method = :test
+    ActionMailer::Base.perform_deliveries = true
+    ActionMailer::Base.deliveries = []
+
+    @expected = TMail::Mail.new
+    @expected.set_content_type "text", "plain", { "charset" => CHARSET }
+  end
+
+  def test_truth
+    assert true
+  end
+
+  private
+    def read_fixture(action)
+      IO.readlines("#{FIXTURES_PATH}/notifier/#{action}")
+    end
+
+    def encode(subject)
+      quoted_printable(subject, CHARSET)
+    end
+end

data/test/unit/person_test.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class PersonTest < Test::Unit::TestCase
+  fixtures :people, LoginEngine.config(:user_table).to_sym
+
+  def setup
+    @person = Person.find(:first)
+  end
+
+  # Replace this with your real tests.
+  def test_truth
+    assert_kind_of Person,  @person
+  end
+
+  def test_collision
+		p = Person.new
+    p.name = "bob10"
+    assert p.save
+
+		p = Person.new
+    p.name = "bob10"
+    assert !p.save
+  end
+end

data/test/unit/user_test.rb

@@ -0,0 +1,94 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class UserTest < Test::Unit::TestCase
+ 
+  fixtures :people, LoginEngine.config(:user_table).to_sym
+
+	def setup
+		LoginEngine::CONFIG[:salt] = "test-salt"
+	end
+
+	def test_auth
+		assert_equal fixture_object(LoginEngine.config(:user_table), :bob), User.authenticate("bob", "atest")  
+
+    assert_nil User.authenticate("nonbob", "atest")
+  end
+
+
+  def test_passwordchange
+		@longbob = users(:longbob)
+    @longbob.change_password("nonbobpasswd")
+    @longbob.save
+    assert_equal @longbob, User.authenticate("longbob", "nonbobpasswd")
+    assert_nil User.authenticate("longbob", "alongtest")
+    @longbob.change_password("alongtest")
+    @longbob.save
+    assert_equal @longbob, User.authenticate("longbob", "alongtest")
+    assert_nil User.authenticate("longbob", "nonbobpasswd")
+  end
+
+  def test_disallowed_passwords
+    u = User.new    
+    u.login = "first"
+
+    u.change_password("tiny")
+    assert !u.save     
+    assert u.errors.invalid?('password')
+
+    u.change_password("hugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehuge")
+    assert !u.save     
+    assert u.errors.invalid?('password')
+        
+    u.change_password("")
+    assert !u.save    
+    assert u.errors.invalid?('password')
+        
+    u.change_password("bobs_secure_password")
+    assert u.save     
+    assert u.errors.empty?
+  end
+  
+  def test_bad_logins
+
+    u = User.new  
+    u.change_password("bobs_secure_password")
+
+    u.login = "bo"
+    assert !u.save     
+    assert u.errors.invalid?('login')
+
+    u.login = "hugebobhugebobhugebobhugebobhugebobhugebobhugebobhugebobhugebobhugebobhugebobhugebobhugebobhugebobhugebobhugebobhugebobhugebobhugebobhugebobhugebobhugebobhugebobhugebobhugebobhugebobhug"
+    assert !u.save
+    assert u.errors.invalid?('login')
+
+    u.login = ""
+    assert !u.save
+    assert u.errors.invalid?('login')
+
+    u.login = "bob2"
+    assert u.save  
+    assert u.errors.empty?
+      
+  end
+
+
+  def test_collision
+    u = User.new
+		u.login = people('bob').name
+    u.change_password("bobs_secure_password")
+    assert !u.save
+  end
+
+
+  def test_create
+		p = Person.new
+    p.name = "otherbob"
+		p.save
+
+    u = User.new
+		u.login = p.name
+    u.change_password("bobs_secure_password")
+
+    assert u.save  
+  end
+end

data/vendor/plugins/engines/CHANGELOG

@@ -0,0 +1,7 @@
+*SVN*
+
+- Added preliminary tests for the config() methods module
+
+- Fixed copyright notices to point to DHH, rather than me.
+- Moved extension require statements into lib/engines.rb, so the will be loaded if another module/file calls require 'engines
+- Added a CHANGELOG file (this file)

data/vendor/plugins/engines/README

@@ -0,0 +1,128 @@
+= Gentlemen, Start your Engines!
+
+=== Quickstart
+
+1. Install the Rails Engines plugin into your plugins directory
+
+2. Install your engine into the plugins directory (note both of these steps will soon be made somewhat <i>automagic</i> by the new Rails script/plugin command coming in Rails 1.0)
+
+3. Create the RDoc for the engine so you know what's going on:
+     $ cd vendor/plugins/my_engine
+     $ rake rdoc
+
+4. Initialize any database schema provided:
+     $ rake db_schema_import      # (still within the plugin/my_engine directory)
+   Beware that this might affect any existing database tables you have installed! You are STRONGLY recommended to inspect the <tt>db/schema.rb</tt> file to see exactly what
+   running it might change.
+
+5. Add configuration to <tt>environment.rb</tt>:
+   e.g.
+      # Add your application configuration here
+      module MyEngine
+        config :top_speed, "MegaTurboFast"
+      end
+ 
+      Engine.start :my_engine
+
+6. Run your server!
+      $ script/server
+
+
+
+= Background
+Rails Engines are a way of dropping in whole chunks of functionality into your
+existing application without affecting *any* of your existing code. The could also be described as mini-applications, or vertical application slices - top-to-bottom units which provide full MVC coverage for a certain, specific application function.
+
+As an example, the Login Engine provides a full user login subsystem, including: 
+* controllers to manage user accounts; 
+* helpers for you to interact with account information from other 
+  parts of your application; 
+* the model objects and schemas to create the required tables; 
+* stylesheets and javascript files to enhance the views; 
+* and any other library files required.
+
+Once the Rails Core team decides on a suitable method for packaging plugins, Engines can be distributed using the same mechanisms. If you are developing engines yourself for use across multiple projects, linking them as svn externals allows seamless updating of bugfixes across multiple applications.
+
+
+
+= Building an Engine
+In your Rails application, you should have a directory called 'engines' in the vendor directory (alongside plugins). This directory will contain one subdirectory for each engine. Here's a sample rails application with a detailed listing of an example engines as a concrete example:
+
+  RAILS_ROOT
+    |- app
+    |- lib
+    |- config
+    |- <... other directories ...>
+    |- vendor
+        |-plugins
+            |- engines               <-- the engines plugin
+            |- some_other_plugin 
+            |- my_engine             <-- our example engine
+                  |- init_engine.rb
+                  |- app
+                  |     |- controllers
+                  |     |- model
+                  |     |- helpers
+                  |     |- views
+                  |- db
+                  |- tasks
+                  |- lib
+                  |- public
+                  |     |- javascripts
+                  |     |- stylesheets
+                  |- test
+
+
+The internal structure of an engine mirrors the familiar core of a Rails application, with most of the engine within the <tt>app</tt> subdirectory. Within <tt>app</tt>, the controllers, views and model objects behave just as you might expect if there in teh top-level <tt>app</tt> directory.
+
+When you call <tt>Engines.start :my_engine</tt> in <tt>environment.rb</tt> a few important bits of black magic voodoo happen:
+* the engine's controllers, views and modesl are mixed in to your running Rails application; 
+* files in the <tt>lib</tt> directory of your engine (and subdirectories) are made available 
+  to the rest of your system
+* any directory structure in the folder <tt>public/</tt> within your engine is made available to the webserver
+* the file <tt>init_engine.rb</tt> is loaded from within the engine (just like a plugin - the reason why engines need an init_engine.rb rather than an init.rb is because Rails' default plugin system might try and load an engine before the Engines plugin has been loaded, resulting in all manner of badness. Instead, Rails' skips over any engine plugins, and the Engines plugin handles initializing your Engines plugins when you 'start' each engine).
+
+From within <tt>init_engine.rb</tt> you should load any libraries from your <tt>lib</tt> directory that your engine might need to function. You can also perform any configuration required.
+
+=== Loading all Engines
+
+Calling either Engines.start (with no arguments) or Engines.start_all will load all engines available. Please note that your plugin can only be detected as an engine by the presence of an 'init_engine.rb' file, or if the engine is in a directory named <something>_engine. If neither of these conditions hold, then your engine will not be loaded by Engines.start() or Engines.start_all().
+
+
+=== Configuring Engines
+Often your engine will require a number of configuration parameters set, some of which should be alterable by the user to reflect their particular needs. For example, a Login System might need a unique Salt value set to encrypt user passwords. This value should be unique to each application.
+
+Engines provides a simple mechanism to handle this, and it's already been hinted at above. Within any module, a new method is now available: <tt>config</tt>. This method creates a special <tt>CONFIG</tt> Hash object within the Module it is called, and can be used to store your parameters. For a user to set these parameters, they should reopen the module (before the corresponding Engine.start call), as follows:
+
+  module MyModule
+    config :some_option, "really_important_value"
+  end
+  Engine.start :my_engine
+
+Because this config value has been set before the Engine is started, subsequent attempts to set this config value will be ignored and the user-specified value used instead. Of course, there are situations where you *really* want to set the config value, even if it already exists. In such cases the config call can be changed to:
+
+  config :some_option, "no_THIS_really_important_value", :force
+
+The additional parameter will force the new value to be used. For more information, see Module#config.
+
+= Tweaking Engines
+One of the best things about Engines is that if you don't like the default behaviour of any component, you can override it without needing to overhaul the whole engine. This makes adding your customisations to engines almost painless, and allows for upgrading/updating engine code without affecting the specialisations you need for your particular application.
+
+
+=== View Tweaks
+These are the simplest - just drop your customised view (or partial) into you <tt>/app/views</tt> directory in the corresponding location for the engine, and your view will be used in preference to the engine view. For example, if we have a ItemController with an action 'show', it will (normally) expect to find its view as <tt>report/show.rhtml</tt> in the <tt>views</tt> directory. The view is found in the engine at <tt>/vendor/engines/my_engine/app/views/report/show.rhtml</tt>. However, if you create the file <tt>/app/views/report/show.rhtml</tt>, that file will be used instead! The same goes for partials.
+
+
+=== Controller Tweaks
+You can override controller behaviour by replacing individual controller methods with your custom behaviour. Lets say that our ItemController's 'show' method isn't up to scratch, but the rest of it behaves just fine. To override the single method, create <tt>/app/controllers/item_controller.rb</tt>, just as if it were going to be a new controller in a regular Rails application. then, implement your show method as you would like it to happen.
+
+... and that's it. Your custom code will be mixed in to the engine controller, replacing its old method with your custom code.
+
+
+=== Model Tweaks
+Alas, tweaking model objects isn't quite so easy (yet). If you need to change the behaviour of model objects, you'll need to copy the model file from the engine into <tt>/app/models</tt> and edit the methods yourself. We're working on improving this.
+
+
+
+= TODO / Future Work
+* some kind of testing? Integrate with the testing stuff at  http://techno-weenie.net/svn/projects/test/ maybe?