sugoi-mail 0.0.0

data/test/unit/user_test.rb

@@ -0,0 +1,126 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+# Set salt to 'change-me' because thats what the fixtures assume. 
+# User.salt = 'change-me'
+
+class UserTest < Test::Unit::TestCase
+    fixtures :users, :domains
+
+    def setup
+        @testuser = User.find 1
+        @users=@loaded_fixtures["users"]
+        @user_testuser=@users["testuser"]
+    end
+
+    def test_aa_break_everything
+        @testuser.destroy
+        assert_raise ActiveRecord::RecordNotFound do
+            User.find @testuser.id
+        end
+    end
+
+    def test_find
+        user_1 = User.find 1
+        assert user_1
+
+        assert_equal @user_testuser["login"], user_1.login
+        assert_equal @user_testuser["password"], user_1.password
+        assert_equal @user_testuser["id"], user_1.mailinglist_id
+    end
+
+    def test_auth_notfound
+        assert_nil    User.authenticate("nontestuser", "foobar")
+    end
+
+    def test_auth
+
+        user_1 = User.find 1
+        assert user_1
+
+        user_testuser = User.authenticate "testuser", "foobar"
+        assert user_testuser
+
+        assert_equal  user_1, user_testuser
+    end
+
+    def test_disallowed_passwords
+
+        u = User.new    
+        u.login = "nonbob"
+        u.domain_id=1
+
+        u.password = u.password_confirmation = "tiny"
+        assert !u.save     
+        assert u.errors.invalid?('password')
+
+        u.password = u.password_confirmation = "hugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehugehuge"
+        assert !u.save     
+        assert u.errors.invalid?('password')
+
+        u.password = u.password_confirmation = ""
+        assert !u.save    
+        assert u.errors.invalid?('password')
+
+        u.password = u.password_confirmation = "bobs_secure_password"
+        assert u.save     
+        # assert u.errors.empty?
+
+    end
+
+    def test_bad_logins
+
+        u = User.new  
+        u.domain_id=1
+        u.password = u.password_confirmation = "bobs_secure_password"
+
+        u.login = "x"
+        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 = "okbob"
+        assert u.save  
+        # assert u.errors.empty?
+
+    end
+
+
+    def test_collision
+        u = User.new
+        u.login      = "testuser"
+        u.domain_id  = 1
+        u.password   = u.password_confirmation = "bobs_secure_password"
+        assert !u.save
+    end
+
+
+    def test_create
+        u = User.new
+        u.login      = "nonexistingbob"
+        u.domain_id  = 1
+        u.password   = u.password_confirmation = "bobs_secure_password"
+
+        assert u.save  
+
+        assert u.mailinglist_id
+    end
+
+    def test_sha1
+        u = User.new
+        u.login      = "nonexistingbob"
+        u.domain_id=1
+        u.password = u.password_confirmation = "bobs_secure_password"
+        assert u.save
+
+        assert_equal '826005bc4b82d02a3e6097556a45083375fe556c', u.password    
+    end
+
+
+end

data/test/units.rb

@@ -0,0 +1,4 @@
+require File.dirname(__FILE__) + '/test_helper'
+Dir["unit/*.rb"].each do |file|
+    require file.sub(/.rb$/,'')
+end

data/vendor/plugins/active_command/init.rb

@@ -0,0 +1 @@
+require "active_command"

data/vendor/plugins/active_command/lib/active_command/request.rb

@@ -0,0 +1,137 @@
+module ActionController
+    class CommandlineSession #:nodoc:
+        def initialize(attributes = {})
+            @attributes = attributes
+        end
+
+        def [](key)
+            @attributes[key]
+        end
+
+        def []=(key, value)
+            @attributes[key] = value
+        end
+
+        def session_id
+          ""
+        end
+
+        def update() end
+        def close() end
+        def delete() @attributes = {} end
+    end
+
+    class CommandlineRequest < AbstractRequest
+        attr_accessor :cookies, :session_options
+        attr_accessor :query_parameters, :request_parameters, :path, :session, :env
+        attr_accessor :host
+
+        def initialize(action, *args)
+            @parameters = { "action" => action,
+                "args" => args.flatten }
+
+            @session            = session || CommandlineSession.new
+
+            initialize_containers
+            initialize_default_values
+
+            super()
+        end
+
+        def reset_session
+            @session = {}
+        end              
+
+        def raw_post
+            if raw_post = env['RAW_POST_DATA']
+                raw_post
+            else
+                params = self.request_parameters.dup
+        %w(controller action only_path).each do |k|
+            params.delete(k)
+            params.delete(k.to_sym)
+        end
+
+        params.map { |k,v| [ CGI.escape(k.to_s), CGI.escape(v.to_s) ].join('=') }.sort.join('&')
+            end
+        end
+
+        def port=(number)
+            @env["SERVER_PORT"] = number.to_i
+            @port_as_int = nil
+        end
+
+        def action=(action_name)
+            @query_parameters.update({ "action" => action_name })
+            @parameters = nil
+        end
+
+        # Used to check AbstractRequest's request_uri functionality.
+        # Disables the use of @path and @request_uri so superclass can handle those.
+        def set_REQUEST_URI(value)
+            @env["REQUEST_URI"] = value
+            @request_uri = nil
+            @path = nil
+        end
+
+        def request_uri=(uri)
+            @request_uri = uri
+            @path = uri.split("?").first
+        end
+
+        def remote_addr=(addr)
+            @env['REMOTE_ADDR'] = addr
+        end
+
+        def remote_addr
+            @env['REMOTE_ADDR']
+        end
+
+        def request_uri
+            @request_uri || super()
+        end
+
+        def path
+            @path || super()
+        end
+
+        def assign_parameters(controller_path, action, parameters)
+            parameters = parameters.symbolize_keys.merge(:controller => controller_path, :action => action)
+            extra_keys = ActionController::Routing::Routes.extra_keys(parameters)
+            non_path_parameters = get? ? query_parameters : request_parameters
+            parameters.each do |key, value|
+                if value.is_a? Fixnum
+                    value = value.to_s
+                elsif value.is_a? Array
+                    value = ActionController::Routing::PathComponent::Result.new(value)
+                end
+
+                if extra_keys.include?(key.to_sym)
+                    non_path_parameters[key] = value
+                else
+                    path_parameters[key.to_s] = value
+                end
+            end
+        end                        
+
+        def recycle!
+            self.request_parameters = {}
+            self.query_parameters   = {}
+            self.path_parameters    = {}
+            @request_method, @accepts, @content_type = nil, nil, nil
+        end    
+
+        private
+        def initialize_containers
+            @env, @cookies = {}, {}
+        end
+
+        def initialize_default_values
+            @host                    = "test.host"
+            @request_uri             = "/"
+            self.remote_addr         = "0.0.0.0"        
+            @env["SERVER_PORT"]      = 80
+            @env['REQUEST_METHOD']   = "GET"
+        end
+    end
+end

data/vendor/plugins/active_command/lib/active_command/response.rb

@@ -0,0 +1,132 @@
+module ActionController
+    class CommandlineResponse < AbstractResponse
+
+        # the response code of the request
+        def response_code
+            headers['Status'][0,3].to_i rescue 0
+        end
+
+        # returns a String to ensure compatibility with Net::HTTPResponse
+        def code
+            headers['Status'].to_s.split(' ')[0]
+        end
+
+        def message
+            headers['Status'].to_s.split(' ',2)[1]
+        end
+
+        # was the response successful?
+        def success?
+            response_code == 200
+        end
+
+        # was the URL not found?
+        def missing?
+            response_code == 404
+        end
+
+        # were we redirected?
+        def redirect?
+            (300..399).include?(response_code)
+        end
+
+        # was there a server-side error?
+        def error?
+            (500..599).include?(response_code)
+        end
+
+        alias_method :server_error?, :error?
+
+        # returns the redirection location or nil
+        def redirect_url
+            redirect? ? headers['location'] : nil
+        end
+
+        # does the redirect location match this regexp pattern?
+        def redirect_url_match?( pattern )
+            return false if redirect_url.nil?
+            p = Regexp.new(pattern) if pattern.class == String
+            p = pattern if pattern.class == Regexp
+            return false if p.nil?
+            p.match(redirect_url) != nil
+        end
+
+        # returns the template path of the file which was used to
+        # render this response (or nil) 
+        def rendered_file(with_controller=false)
+            unless template.first_render.nil?
+                unless with_controller
+                    template.first_render
+                else
+                    template.first_render.split('/').last || template.first_render
+                end
+            end
+        end
+
+        # was this template rendered by a file?
+        def rendered_with_file?
+            !rendered_file.nil?
+        end
+
+        # a shortcut to the flash (or an empty hash if no flash.. hey! that rhymes!)
+        def flash
+            session['flash'] || {}
+        end
+
+        # do we have a flash? 
+        def has_flash?
+            !session['flash'].empty?
+        end
+
+        # do we have a flash that has contents?
+        def has_flash_with_contents?
+            !flash.empty?
+        end
+
+        # does the specified flash object exist?
+        def has_flash_object?(name=nil)
+            !flash[name].nil?
+        end
+
+        # does the specified object exist in the session?
+        def has_session_object?(name=nil)
+            !session[name].nil?
+        end
+
+        # a shortcut to the template.assigns
+        def template_objects
+            template.assigns || {}
+        end
+
+        # does the specified template object exist? 
+        def has_template_object?(name=nil)
+            !template_objects[name].nil?      
+        end
+
+        # Returns the response cookies, converted to a Hash of (name => CGI::Cookie) pairs
+        # Example:
+        # 
+        # assert_equal ['AuthorOfNewPage'], r.cookies['author'].value
+        def cookies
+            headers['cookie'].inject({}) { |hash, cookie| hash[cookie.name] = cookie; hash }
+        end
+
+        # Returns binary content (downloadable file), converted to a String
+        def binary_content
+            raise "Response body is not a Proc: #{body.inspect}" unless body.kind_of?(Proc)
+            require 'stringio'
+
+            sio = StringIO.new
+
+            begin 
+                $stdout = sio
+                body.call
+            ensure
+                $stdout = STDOUT
+            end
+
+            sio.rewind
+            sio.read
+        end
+    end
+end

data/vendor/plugins/active_command/lib/active_command.rb

@@ -0,0 +1,2 @@
+require "active_command/request"
+require "active_command/response"

data/vendor/plugins/ar_fixtures/CHANGELOG

@@ -0,0 +1,10 @@
+
+== May 20, 2006
+
+* Added to_skeleton for writing fieldnames only. [Gunther Schmidl]
+* Added initial tests, thanks to Scott Barron's acts_as_state_machine
+
+== Jan 12 2006
+
+* Added code to handle single table inheritance. May need to be modified for non-standard use of STI.
+

data/vendor/plugins/ar_fixtures/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2005 Geoffrey Grosenbach
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/plugins/ar_fixtures/README

@@ -0,0 +1,19 @@
+= ar_fixtures
+
+This library makes it easy to save ActiveRecord objects to reloadable files or fixtures.  ActiveRecord is required.
+
+See tasks/ar_fixtures.rake for what can be done from the command-line, or use "rake -T" and look for items in the "db" namespace.
+
+== Resources
+
+Subversion
+
+* http://topfunky.net/svn/plugins/ar_fixtures
+
+Blog
+
+* http://nubyonrails.com
+
+Author
+
+* Geoffrey Grosenbach boss [at] topfunky [dot] com

data/vendor/plugins/ar_fixtures/Rakefile

@@ -0,0 +1,54 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => [:clean, :test]
+
+desc "Delete test-generated files"
+task :clean do
+  %w(sqlite sqlite3).each do |db_name|
+    rm_f File.join(File.dirname(__FILE__), 'test', "plugin.#{db_name}.db")
+  end
+  rm_f File.join(File.dirname(__FILE__), 'test', 'debug.log')
+end
+
+desc 'Test the plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActiveRecord Fixtures'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+# 
+# def sort_files(glob, pattern)
+#   %(for f in #{glob}; do grep "#{pattern}" $f > x; sort x > y; if ! diff x y > z ; then echo $f; echo; cat z; fi; done; rm -f x y z)
+# end
+# 
+# namespace :zentest do
+# 
+#   desc "Generates test stub code for libraries"
+#   task :lib do
+#     tests = Dir["test/*_test.rb"]
+#     libs = Dir["lib/*.rb"]
+#     ruby "-S -I. ZenTest -r #{tests.join ' '} #{libs.join ' '}"
+#   end
+# 
+#   task :sort do
+#     sh sort_files('lib/*.rb', 'def ')
+#     sh sort_files('test/*_test.rb', 'def.test_')
+#   end
+# 
+#   task :audit_libs => [ :lib, :sort ]
+# 
+# end
+# 

data/vendor/plugins/ar_fixtures/about.yml

@@ -0,0 +1,7 @@
+author: topfunky
+summary: Use the existing data in your database to generate fixtures, fixture skeletons, and reference YAML files.
+homepage: http://nubyonrails.com
+plugin: http://topfunky.net/svn/plugins/ar_fixtures
+license: MIT
+version: 0.2
+rails_version: 1.0+

data/vendor/plugins/ar_fixtures/init.rb

@@ -0,0 +1 @@
+require 'ar_fixtures'

data/vendor/plugins/ar_fixtures/lib/ar_fixtures.rb

@@ -0,0 +1,102 @@
+# Extension to make it easy to read and write data to a file.
+class ActiveRecord::Base
+
+  class << self
+
+    # Writes content of this table to db/table_name.yml, or the specified file.
+    #
+    # Writes all content by default, but can be limited.
+    def dump_to_file(path=nil, limit=nil)
+      opts = {}
+      opts[:limit] = limit if limit
+      path ||= "db/#{table_name}.yml"
+      write_file(File.expand_path(path, RAILS_ROOT), self.find(:all, opts).to_yaml)
+    end
+  
+    # Delete existing data in database and load fresh from file in db/table_name.yml
+    def load_from_file(path=nil)
+      path ||= "db/#{table_name}.yml"
+
+      self.destroy_all
+
+      if connection.respond_to?(:reset_pk_sequence!)
+       connection.reset_pk_sequence!(table_name)
+      end
+
+      records = YAML::load( File.open( File.expand_path(path, RAILS_ROOT) ) )
+      records.each do |record|
+        record_copy = self.new(record.attributes)
+        record_copy.id = record.id
+
+        # For Single Table Inheritance
+        klass_col = record.class.inheritance_column.to_sym
+        if record[klass_col]
+           record_copy.type = record[klass_col]
+        end
+      
+        record_copy.save
+      end
+ 
+      if connection.respond_to?(:reset_pk_sequence!)
+       connection.reset_pk_sequence!(table_name)
+      end
+    end
+
+    # Write a file that can be loaded with +fixture :some_table+ in tests.
+    # Uses existing data in the database.
+    #
+    # Will be written to +test/fixtures/table_name.yml+. Can be restricted to some number of rows.
+    def to_fixture(limit=nil)
+      opts = {}
+      opts[:limit] = limit if limit
+
+      write_file(File.expand_path("test/fixtures/#{table_name}.yml", RAILS_ROOT), 
+          self.find(:all, opts).inject({}) { |hsh, record| 
+              hsh.merge("#{table_name.singularize}_#{record.id}" => record.attributes) 
+            }.to_yaml)
+      habtm_to_fixture
+    end
+
+    # Write the habtm association table
+    def habtm_to_fixture
+      joins = self.reflect_on_all_associations.select { |j|
+        j.macro == :has_and_belongs_to_many
+      }
+      joins.each do |join|
+        hsh = {}
+        connection.select_all("SELECT * FROM #{join.options[:join_table]}").each_with_index { |record, i|
+          hsh["join_#{i}"] = record
+        }
+        write_file(File.expand_path("test/fixtures/#{join.options[:join_table]}.yml", RAILS_ROOT), hsh.to_yaml)
+      end
+    end
+    
+    # Generates a basic fixture file in test/fixtures that lists the table's field names.
+    #
+    # You can use it as a starting point for your own fixtures.
+    #
+    #  record_1:
+    #    name:
+    #    rating:
+    #  record_2:
+    #    name:
+    #    rating:
+    #
+    def to_skeleton
+      record = { 
+          "record_1" => self.new.attributes,
+          "record_2" => self.new.attributes
+         }
+      write_file(File.expand_path("test/fixtures/#{table_name}.yml", RAILS_ROOT),
+        record.to_yaml)
+    end
+
+    def write_file(path, content) # :nodoc:
+      f = File.new(path, "w+")
+      f.puts content
+      f.close
+    end
+
+  end
+
+end

data/vendor/plugins/ar_fixtures/tasks/ar_fixtures.rake

@@ -0,0 +1,39 @@
+
+def env_or_raise(var_name, human_name)
+  if ENV[var_name].blank?
+    raise "No #{var_name} value given. Set #{var_name}=#{human_name}"
+  else
+    return ENV[var_name]
+  end  
+end
+
+def model_or_raise
+  return env_or_raise('MODEL', 'ModelName')
+end
+
+def limit_or_nil_string
+  ENV['LIMIT'].blank? ? 'nil' : ENV['LIMIT']
+end
+
+namespace :db do
+  namespace :fixtures do
+    desc "Dump data to fixture files. Use MODEL=ModelName and LIMIT (optional)"
+    task :dump => :environment do
+      eval "#{model_or_raise}.to_fixture(#{limit_or_nil_string})"
+    end
+  end
+  
+  
+  namespace :data do
+    desc "Dump current data to YAML. Use MODEL=ModelName and LIMIT (optional)"
+    task :dump => :environment do
+      eval "#{model_or_raise}.dump_to_file(nil, #{limit_or_nil_string})"
+      puts "#{model_or_raise} has been dumped to the db folder."
+    end
+
+    desc "Load data from YAML dumped by the ar_fixtures plugin. Use MODEL=ModelName"
+    task :load => :environment do
+      eval "#{model_or_raise}.load_from_file"
+    end
+  end
+end