picolena 0.0.99

data/app_generators/picolena/templates/script/spec_server

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../rspec/lib' # For svn
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../vendor/plugins/rspec/lib' # For rspec installed as plugin
+require 'rubygems'
+require 'drb/drb'
+require 'rbconfig'
+require 'spec'
+require 'optparse'
+
+# This is based on Florian Weber's TDDMate
+module Spec
+  module Runner
+    class RailsSpecServer
+      def run(argv, stderr, stdout)
+        $stdout = stdout
+        $stderr = stderr
+
+        base = ActiveRecord::Base
+        def base.clear_reloadable_connections!
+          active_connections.each do |name, conn|
+            if conn.requires_reloading?
+              conn.disconnect!
+              active_connections.delete(name)
+            end
+          end
+        end        
+
+        if ActionController.const_defined?(:Dispatcher)
+          dispatcher = ::ActionController::Dispatcher.new($stdout)
+          dispatcher.cleanup_application(true)
+        elsif ::Dispatcher.respond_to?(:reset_application!)
+          ::Dispatcher.reset_application!
+        else
+          raise "Application reloading failed"
+        end
+        ::Dependencies.mechanism = :load
+        require_dependency('application.rb') unless Object.const_defined?(:ApplicationController)
+        load File.dirname(__FILE__) + '/../spec/spec_helper.rb'
+
+        ::Spec::Runner::CommandLine.run(
+          ::Spec::Runner::OptionParser.parse(
+            argv,
+            $stderr,
+            $stdout
+          )
+        )
+      end
+    end
+  end
+end
+puts "Loading Rails environment"
+
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
+require 'dispatcher'
+
+def restart_test_server
+  puts "restarting"
+  config       = ::Config::CONFIG
+  ruby         = File::join(config['bindir'], config['ruby_install_name']) + config['EXEEXT']
+  command_line = [ruby, $0, ARGV].flatten.join(' ')
+  exec(command_line)
+end
+
+def daemonize(pid_file = nil)
+  return yield if $DEBUG
+  pid = Process.fork{
+    Process.setsid
+    Dir.chdir(RAILS_ROOT)
+    trap("SIGINT"){ exit! 0 }
+    trap("SIGTERM"){ exit! 0 }
+    trap("SIGHUP"){ restart_test_server }
+    File.open("/dev/null"){|f|
+      STDERR.reopen f
+      STDIN.reopen  f
+      STDOUT.reopen f
+    }
+    yield
+  }
+  puts "spec_server launched. (PID: %d)" % pid
+  File.open(pid_file,"w"){|f| f.puts pid } if pid_file
+  exit! 0
+end
+
+options = Hash.new
+opts = OptionParser.new
+opts.on("-d", "--daemon"){|v| options[:daemon] = true }
+opts.on("-p", "--pid PIDFILE"){|v| options[:pid] = v }
+opts.parse!(ARGV)
+
+puts "Ready"
+exec_server = lambda {
+  trap("USR2") { restart_test_server } if Signal.list.has_key?("USR2")
+  DRb.start_service("druby://localhost:8989", Spec::Runner::RailsSpecServer.new)
+  DRb.thread.join
+}
+
+if options[:daemon]
+  daemonize(options[:pid], &exec_server)
+else
+  exec_server.call
+end

data/app_generators/picolena/templates/spec/controllers/application_controller_spec.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe ApplicationController do
+  it "should give 403 when denying access" do
+    get 'access_denied'
+    response.headers["Status"].should == "403 Forbidden"
+  end
+  
+  it "should flash with a wrong request" do
+    get 'unknown_request'
+    response.should be_redirect
+    response.should redirect_to(documents_url)
+    flash[:warning].should == "Unknown URL"
+  end
+end

data/app_generators/picolena/templates/spec/controllers/documents_controller_spec.rb

@@ -0,0 +1,114 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "DocumentsController called from unknown IP" do
+  controller_name "documents"
+  
+  before(:all) do
+    @backup=WhiteListIPs
+  end
+  
+  it "should deny access" do
+    WhiteListIPs=/Something that won't match/
+    get 'index'
+    response.should be_redirect
+    response.should redirect_to(:controller=>'application', :action=>'access_denied')
+    WhiteListIPs=/^0\.0\.0\.0/
+    get 'index'
+    response.should be_success
+  end
+
+  after(:all) do
+    WhiteListIPs=@backup
+  end
+end
+
+describe DocumentsController do  
+  it "GET 'index' should be succesful" do
+    get 'index'
+    response.should be_success
+  end
+  
+  it "POST 'check_query' should check query and redirect to show" do
+    post 'check_query', {:query => 'basic test'}
+    response.should be_redirect
+    response.should redirect_to(document_url('basic test')) 
+  end
+  
+  it "POST 'check_query' should accept . and redirect to show" do
+    post 'check_query', {:query => 'basic.test'}
+    response.should be_redirect
+    response.should redirect_to(:action=>'show', :id=>'basic.test')
+  end
+  
+  it "POST 'check_query' should accept ? and redirect to show" do
+    post 'check_query', {:query => '?ric'}
+    response.should be_redirect
+    response.should redirect_to(:action=>'show', :id=>'?ric') 
+  end
+  
+  it "POST 'check_query' should accept empty query but should redirect to index" do
+    post 'check_query', {:query => ''}
+    response.should be_redirect
+    response.should redirect_to(:action=>'index')
+  end
+  
+  it "GET 'show' should find corresponding docs" do
+    get 'show', :id=>'forschung an fachhochschulen nachhaltige energietechnik'
+    response.should be_success
+    assigns[:matching_documents].any?{|doc| doc.filename=="zafh.net.html"}.should be_true
+  end
+  
+  it "GET 'show' should accept * in queries" do
+    lambda{get 'show', :id=>'*ric'}.should_not raise_error
+    response.should be_success
+    assigns[:matching_documents].entries.should_not be_empty
+    assigns[:matching_documents].any?{|doc| doc.matching_content.join.starts_with?("<<Éric>> Mößer\n\n\f")}.should be_true
+  end
+  
+  it "GET 'show' should accept ? in queries" do
+    lambda{get 'show', :id=>'?ric'}.should_not raise_error(ActionController::RoutingError)
+    response.should be_success
+    assigns[:matching_documents].entries.should_not be_empty
+    assigns[:matching_documents].any?{|doc| doc.filename=="basic.tex"}.should be_true
+  end
+    
+  it "GET 'show' should accept . in queries" do
+    lambda{get 'show', :id=>'basic.pdf'}.should_not raise_error(ActionController::RoutingError)
+    response.should be_success
+    assigns[:matching_documents].entries.should_not be_empty
+    assigns[:matching_documents].any?{|doc| doc.matching_content.join.starts_with?("just another content test in a pdf file")}.should be_true
+  end
+  
+  it "GET 'show' should accept combined queries" do
+    get 'show', :id=>'test filetype:pdf'
+    response.should be_success
+    assigns[:matching_documents].entries.should_not be_empty
+  end
+  
+  it "GET 'show' should accept empty query but should redirect to index" do
+    lambda{get 'show', :id=>''}.should_not raise_error
+    response.should be_success
+    assigns[:matching_documents].entries.should be_empty
+  end
+  
+  it "GET 'download' should be successful with correct ID" do
+    get 'show', :id=>'basic.pdf'
+    response.should be_success
+    assigns[:matching_documents].entries.should_not be_empty
+    d=assigns[:matching_documents].entries.first
+    get 'download', :id=>d.md5
+    assigns[:document].complete_path == d.complete_path
+    response.should be_success
+  end
+  
+  it "GET 'download' should redirect if wrong id" do
+    md5=Digest::MD5.hexdigest("Not a document")
+    get 'download', :id=>md5
+    response.should be_redirect
+    response.should redirect_to(documents_url)
+    md5='sdfgsdgf'
+    get 'download', :id=>md5
+    response.should be_redirect
+    response.should redirect_to(documents_url)
+  end
+end

data/app_generators/picolena/templates/spec/helpers/application_helper_spec.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe ApplicationHelper do
+  
+  #Delete this example and add some real ones or delete this file
+  it "should include the ApplicationHelper" do
+    included_modules = self.metaclass.send :included_modules
+    included_modules.should include(ApplicationHelper)
+  end
+  
+end

data/app_generators/picolena/templates/spec/helpers/documents_helper_spec.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe DocumentsHelper do  
+  it "shouldn't raise if matching not in content field"
+
+  PlainText.supported_extensions.each{|ext|
+    it "should have an icon for .#{ext} filetype" do 
+      icon_for(ext.to_s).should_not be_nil
+    end
+  }
+end

data/app_generators/picolena/templates/spec/models/basic_finder_spec.rb

@@ -0,0 +1,108 @@
+require "tmpdir"
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Finder without index on disk" do
+  before(:all) do
+    @original_index_path=IndexSavePath.dup
+    @original_indexed_dirs=IndexedDirectories.dup
+    @new_index_path=File.join(Dir::tmpdir,'ferret_tst')
+    IndexSavePath.replace(@new_index_path)
+  end
+  
+  before(:each) do
+    Finder.delete_index
+  end
+  
+  it "should create index" do
+    IndexedDirectories.replace({'spec/test_dirs/indexed/just_one_doc'=>'//justonedoc/'})
+    lambda {@finder_with_new_index=Finder.new("test moi")}.should change(Finder, :has_index?).from(false).to(true)
+    File.exists?(File.join(@new_index_path,'_0.cfs')).should be_true
+    @finder_with_new_index.index.size.should >0
+  end
+  
+  it "should raise if index is still empty after trying to create it" do
+    IndexedDirectories.replace({'spec/test_dirs/empty_folder'=>'//empty_folder/'})
+    lambda {Finder.new("doesn't matter anyway")}.should raise_error(IndexError, "no document found")
+    File.exists?(File.join(@new_index_path,'_0.cfs')).should be_false
+  end
+  
+  after(:all) do
+    IndexedDirectories.replace(@original_indexed_dirs)
+    IndexSavePath.replace(@original_index_path)
+  end
+end
+
+
+fields={
+  # description => key
+  :content=>:content,
+  :basename=>:basename,
+  :filename=>:file,
+  :extension => :filetype,
+  :modification_time=>:date
+}
+
+describe "Basic Finder" do  
+  before(:all) do
+    Finder.force_index_creation
+  end
+  
+  it "should accept one parameter as query, and 2 optionals for paginating" do
+    lambda {Finder.new}.should raise_error(ArgumentError, "wrong number of arguments (0 for 1)")
+    # show first page with 10 results per page
+    lambda {Finder.new("a b")}.should_not raise_error
+    # show second page
+    lambda {Finder.new("a", 2)}.should_not raise_error
+    # show first page with 15 results
+    lambda {Finder.new("a", 1, 15)}.should_not raise_error
+    # Too many parameters
+    lambda {Finder.new("a", 10, 20, 30)}.should raise_error(ArgumentError, "wrong number of arguments (4 for 3)")
+  end
+
+  it "should return matching documents if executed successfully" do
+    finder_with_valid_query=Finder.new("district heating")
+    finder_with_valid_query.should respond_to(:matching_documents)
+    
+    matching_documents=finder_with_valid_query.matching_documents
+    matching_documents.should_not be_empty
+    
+    matching_documents_filenames=matching_documents.collect{|d| d.filename}
+    matching_documents_filenames.should include("Simulation of district heating systems for evaluation of real-time control strategies.pdf")
+    matching_documents_filenames.should include("Types of malfunction in DH substations.doc")
+  end
+  
+  it "should know if it has been executed" do
+    @finder=Finder.new("some query")
+    lambda {@finder.execute!}.should change(@finder, :executed?).from(false).to(true)
+  end
+  
+  it "should know if index is up to date" do
+    Finder.has_index?.should be_true
+    Finder.should respond_to(:up_to_date?)
+    Finder.should be_up_to_date
+  end
+  
+  it "should not warn anything if index is up to date"
+  
+  it "should warn if index is not up to date"
+  
+  fields.each_pair do |description,field_name|
+    it "should index #{description} as :#{field_name}" do
+      @finder=Finder.new("some query")
+      @finder.index.field_infos[field_name].should be_an_instance_of(Ferret::Index::FieldInfo)
+    end
+  end
+  
+  it "should know how much time was needed for execution" do
+    finder=Finder.new("yet another stupid query")
+    finder.executed?.should be_nil
+    finder.time_needed.should > 0
+    finder.executed?.should be_true
+  end
+  
+  it "should not need more than 100ms to find documents" do
+    finder=Finder.new("district heating")
+    finder.execute!
+    finder.time_needed.should < 0.1
+  end
+end

data/app_generators/picolena/templates/spec/models/document_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+basic_pdf_attribute={
+  :size=>9380,
+  :dirname=>'spec/test_dirs/indexed/basic',
+  :basename=>'basic',
+  :complete_path=>'spec/test_dirs/indexed/basic/basic.pdf',
+  :extname=>'.pdf',
+  :filename=>'basic.pdf'
+}
+
+describe Document do
+  before(:each) do
+    @valid_random_doc=Document.find(:random) rescue Document.new("spec/test_dirs/indexed/basic/basic.pdf")
+  end
+  
+  it "should be an existing file" do
+    lambda {Document.new("/patapouf.txt")}.should raise_error(Errno::ENOENT)
+    lambda {@valid_random_doc}.should_not raise_error
+    lambda {Document.new("spec/test_dirs/not_indexed/Rakefile")}.should_not raise_error(Errno::ENOENT)
+  end
+  
+  it "should belong to an indexed directory" do
+    lambda {@valid_random_doc}.should_not raise_error
+    lambda {Document.new("spec/test_dirs/not_indexed/Rakefile")}.should raise_error(ArgumentError, "required document is not in indexed directory")
+  end
+  
+  basic_pdf_attribute.each{|attribute,expected_value|
+    it "should know its #{attribute}" do
+      @valid_random_doc.should respond_to(attribute)
+      @basic_pdf=Document.new('spec/test_dirs/indexed/basic/basic.pdf')
+      @basic_pdf.send(attribute).should == expected_value
+    end
+  }
+  
+  it "should know which user it belongs to, if specified" do
+    @valid_random_doc.should respond_to(:user)
+    @valid_random_doc.user.should be_nil
+    @valid_random_doc.user="eric"
+    @valid_random_doc.user.should == "eric"
+  end
+  
+  it "should know its content" do
+    another_doc=Document.new("spec/test_dirs/indexed/basic/plain.txt")
+    another_doc.content.should == "just a content test\nin a txt file"
+  end
+ 
+  it "should know its alias_path" do
+    @valid_random_doc.should respond_to(:alias_path)
+    @valid_random_doc.alias_path.starts_with?("http://picolena.devjavu.com/browser/trunk/spec/test_dirs/indexed").should be_true
+  end
+  
+  it "should let finder specify its score" do
+    @valid_random_doc.should respond_to(:score)
+    @valid_random_doc.score.should be_nil
+    @valid_random_doc.score=25
+    @valid_random_doc.score.should == 25
+  end
+  
+  it "should let finder specify its matching content" do
+    @valid_random_doc.should respond_to(:matching_content)
+    @valid_random_doc.matching_content.should be_nil
+    @valid_random_doc.matching_content=["thermal cooling", "heat driven cooling"]
+    @valid_random_doc.matching_content.should include("thermal cooling")
+  end
+end

data/app_generators/picolena/templates/spec/models/filters_spec.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Filters" do
+  before(:all) do
+    Finder.ensure_that_index_exists_on_disk
+  end  
+  
+  PlainText.filters.each{|filter|
+    filter.exts.each{|ext|
+      should_extract= "should be able to extract content from #{filter.description} (.#{ext})"
+      content_and_file_examples_for_this_ext=filter.content_and_file_examples.select{|content,file| File.ext_as_sym(file)==ext}
+      unless content_and_file_examples_for_this_ext.empty? then
+        it should_extract do
+          content_and_file_examples_for_this_ext.each{|content_example,file_example|
+            finder=Finder.new(content_example)
+            finder.execute!
+            matching_documents=finder.matching_documents
+            matching_documents_filenames=matching_documents.collect{|d| d.filename}
+            matching_documents_filenames.should include(file_example)
+          }
+        end
+      else
+        ## It means that the spec for this extension file is "Not yet implemented"!
+        ## add this line to the corresponding filter in lib/filters:
+        # which_should_for_example_extract 'some content', :from => 'a file you could add in spec/test_dirs/indexed/'
+        it should_extract
+      end
+    }
+  }
+end