tenjin 0.6.2 → 0.7.0

data/test/test_main.yaml

@@ -1,6 +1,6 @@
 ###
-### $Rev: 61 $
-### $Date: 2007-08-04 13:23:33 +0900 (Sat, 04 Aug 2007) $
+### $Rev$
+### $Date$
 ###
 
 ###

data/test/test_safe.rb

@@ -0,0 +1,206 @@
+###
+### $Rev$
+### $Release: 0.7.0 $
+### copyright(c) 2007-2011 kuwata-lab.com all rights reserved
+###
+
+require "#{File.dirname(File.expand_path(__FILE__))}/test_all"
+
+
+class SafeStringTest
+  include Oktest::TestCase
+
+  def test_to_s
+    spec "return self" do
+      sstr = Tenjin::SafeString.new('<>')
+      ok_(sstr.to_s).same?(sstr)
+      ok_(sstr) == '<>'   # not escaped!
+    end
+  end
+
+end
+
+
+class SefeHelperTest
+  include Oktest::TestCase
+  include Tenjin::ContextHelper
+  include Tenjin::HtmlHelper
+  include Tenjin::SafeHelper
+
+  def test_safe_str
+    spec "convert value into SafeString object" do
+      ok_(safe_str('<>')).is_a?(Tenjin::SafeString)
+      ok_(safe_str(nil)).is_a?(Tenjin::SafeString)
+      ok_(safe_str(123)).is_a?(Tenjin::SafeString)
+    end
+  end
+
+  def test_safe_str?
+    spec "return true if arg is SafeString" do
+      sstr = Tenjin::SafeString.new('<>')
+      ok_(safe_str?(sstr)) == true
+    end
+    spec "return false if arg is not SafeString" do
+      ok_(safe_str?('<>')) == false
+    end
+  end
+
+  def test_safe_escape
+    sstr = safe_str('<>')
+    spec "escape arg if it is not SafeString" do
+      ok_(safe_escape('<>')) == '&lt;&gt;'
+    end
+    spec "don't escape arg if it is SafeString" do
+      ok_(safe_escape(sstr)) == '<>'
+    end
+    spec "return SafeString object regardless arg is SafeString or not" do
+      ok_(safe_escape('<>')).is_a?(Tenjin::SafeString)
+      ok_(safe_escape(sstr)).is_a?(Tenjin::SafeString)
+    end
+  end
+
+  def test_FUNC
+    #include Tenjin::HtmlHelper
+    #include Tenjin::SafeHelper
+    ##
+    #s = "<AAA>"
+    #puts safe_str?(s)     #=> false
+    #s = safe_escape(s)    # same as SafeString.new(escape(s))
+    #puts safe_str?(s)     #=> true
+    #puts s                #=> &lt;AAA&gt;
+    #puts safe_escape(s)   #=> &lt;AAA&gt;
+    ##
+    #s = "<AAA>"
+    #s = safe_str(s)       # same as SafeString.new(s0
+    #puts safe_str?(s)     #=> true
+    #puts s                #=> <AAA>
+    #puts safe_escape(s)   #=> <AAA>
+    #
+    s = "<AAA>"
+    ok_(safe_str?(s)) == false
+    s = safe_escape(s)
+    ok_(safe_str?(s)) == true
+    ok_(s.to_s) == "&lt;AAA&gt;"
+    ok_(safe_escape(s).to_s) == "&lt;AAA&gt;"
+    #
+    s = "<AAA>"
+    s = safe_str(s)       # same as SafeString.new(s)
+    ok_(safe_str?(s)) == true
+    ok_(s.to_s) == "<AAA>"
+    ok_(safe_escape(s).to_s) == "<AAA>"
+  end
+
+end
+
+
+class SafeTemplateTest
+  include Oktest::TestCase
+
+  def test_initialize
+    t = Tenjin::SafeTemplate.new(nil)
+    spec "default escapefunc is 'safe_escape'." do
+      ok_(t.escapefunc) == 'safe_escape'
+    end
+  end
+
+  def test_escape_str
+    t = Tenjin::SafeTemplate.new(nil)
+    t.instance_variable_set('@newline', nil)  # avoid warning
+    spec "escapes '#'" do
+      ok_(t.escape_str('<#><`><\\>')) == '<\\#><\\`><\\\\>'
+    end
+  end
+
+  def test_FUNCTEST_convert_and_render
+    input = <<'END'
+<p>@v1=${@v1}</p>
+<p>@v2=${@v2}</p>
+<p>safe_str(@v1)=${safe_str(@v1)}</p>
+<p>safe_str(@v2)=${safe_str(@v2)}</p>
+END
+    script = <<'END'
+ _buf << %Q`<p>@v1=#{safe_escape((@v1).to_s)}</p>
+<p>@v2=#{safe_escape((@v2).to_s)}</p>
+<p>safe_str(@v1)=#{safe_escape((safe_str(@v1)).to_s)}</p>
+<p>safe_str(@v2)=#{safe_escape((safe_str(@v2)).to_s)}</p>\n`
+END
+    output = <<'END'
+<p>@v1=&lt;&gt;</p>
+<p>@v2=<></p>
+<p>safe_str(@v1)=<></p>
+<p>safe_str(@v2)=<></p>
+END
+    t = Tenjin::SafeTemplate.new(nil)
+    spec "'\#' should be escaped with backslash." do
+      ok_(t.convert('<<#{true}>>')) == ' _buf << %Q`<<\\#{true}>>`; ' + "\n"
+    end
+    spec "use safe_escape() as escape function." do
+      ok_(t.convert(input)) == script
+    end
+    spec "'${s}' doesn't escape if s is SafeString object." do
+      context = {:v1=>'<>', :v2=>Tenjin::SafeString.new('<>')}
+      ok_(t.render(context)) == output
+    end
+    spec "escapes when input text is passed via :input option" do
+      t = Tenjin::SafeTemplate.new(:input=>input)
+      ok_(t.script) == script
+    end
+  end
+
+end
+
+
+class SafeEngineTest
+  include Oktest::TestCase
+
+  def test_initialize
+    spec "use SafeTemplate as default template class." do
+      e = Tenjin::SafeEngine.new
+      ok_(e.templateclass) == Tenjin::SafeTemplate
+    end
+  end
+
+  def test_FUNCTEST_render
+    input = <<'END'
+<?rb for item in @items ?>
+<tr>
+ <td>#{item}</td>
+ <td>${item}</td>
+ <td>${safe_str(item)}</td>
+</tr>
+<?rb end ?>
+END
+    expected = <<'END'
+<tr>
+ <td>#{item}</td>
+ <td>&lt;&gt;</td>
+ <td><></td>
+</tr>
+<tr>
+ <td>#{item}</td>
+ <td><></td>
+ <td><></td>
+</tr>
+END
+    begin
+      fname = 'test_safeengine.rbhtml'
+      File.open(fname, 'w') {|f| f.write(input) }
+      spec "String is escaped but SafeString is not." do
+        engine = Tenjin::SafeEngine.new(:postfix=>'.rbhtml')
+        context = {:items=>['<>', Tenjin::SafeString.new('<>')]}
+        output = engine.render(fname, context)
+        ok_(output) == expected
+      end
+    ensure
+      [fname, fname+'.cache'].each do |f|
+        File.unlink(f) if File.exist?(f)
+      end
+    end
+  end
+
+end
+
+
+if __FILE__ == $0
+  Oktest.run_all()
+end

data/test/test_store.rb

@@ -0,0 +1,220 @@
+###
+### $Rev$
+### $Release: 0.7.0 $
+### copyright(c) 2007-2011 kuwata-lab.com all rights reserved
+###
+
+require "#{File.dirname(File.expand_path(__FILE__))}/test_all"
+require 'fileutils'
+require 'oktest'
+
+
+class KeyValueStoreTest
+  include Oktest::TestCase
+
+  def before
+    @store = Tenjin::MemoryBaseStore.new()
+  end
+
+  def test_setter
+    @store['key1'] = 'value1'
+    ok_(@store.get('key1')) == 'value1'
+  end
+
+  def test_getter
+    @store.set('key1', 'value1')
+    ok_(@store['key1']) == 'value1'
+    ok_(@store['key9']) == nil
+  end
+
+end
+
+
+class MemoryBaseStoreTest
+  include Oktest::TestCase
+
+  def before
+    @store = Tenjin::MemoryBaseStore.new()
+    @key   = "foo/123[456]"
+    @value = "FOOOOOO"
+  end
+
+  def test_set
+    spec "store key and value with current and expired timestamp" do
+      now = Time.now
+      @store.set(@key, @value)
+      ok_(@store.values.length) == 1
+      #ok_(now, now + @store.lifetime], @store.values[@key]) == [@value
+      ok_(@store.values[@key].inspect) == [@value, now, now + @store.lifetime].inspect
+    end
+  end
+
+  def test_get
+    now = Time.now
+    @store.set(@key, @value)
+    spec "return cache data" do
+      ok_(@store.get(@key)) == @value
+    end
+    spec "if cache data is not found, return nil" do
+      ok_(@store.get('hogehoge')) == nil
+    end
+    spec "if cache data is older than original data, remove it and return nil" do
+      ok_(@store.get(@key, now - 1)) == @value  # cache data is newer than original
+      ok_(@store.values.length) == 1
+      ok_(@store.get(@key, now + 1)) == nil  # cache data is older than original
+      ok_(@store.values.length) == 0
+    end
+    spec "if cache data is expired then remove it and return nil" do
+      @store.set(@key, @value)
+      @store.values[@key][-1] = now - 1
+      ok_(@store.get(@key)) == nil
+      ok_(@store.values.length) == 0
+    end
+  end
+
+  def test_del
+    @store.set(@key, @value)
+    spec "remove data" do
+      ok_(@store.values.length) == 1
+      @store.del(@key)
+      ok_(@store.values.length) == 0
+    end
+    spec "don't raise error even if key doesn't exist" do
+      not_ok_(proc { @store.del(@key) }).raise?(Exception)
+    end
+  end
+
+  def test_has?
+    spec "if key exists then return true else return false" do
+      ok_(@store.has?(@key)) == false
+      @store.set(@key, @value)
+      ok_(@store.has?(@key)) == true
+    end
+  end
+
+
+
+end
+
+
+class FileBaseStoreTest
+  include Oktest::TestCase
+
+  def before
+    @klass = Tenjin::FileBaseStore
+    @cachedir = '.test.store'
+    Dir.mkdir(@cachedir)
+    @store = @klass.new(@cachedir)
+    @key = "foo/123[456]"
+    @data = "FOOOOO"
+    @fpath = @store.filepath(@key)
+  end
+
+  def after
+    FileUtils.rm_rf(@cachedir)
+  end
+
+  def test_initialize
+    spec "if passed root dir doesn't exist then raise error" do
+      ok_(proc { @klass.new('/voo/doo') }).raise?(ArgumentError, "/voo/doo: not found.")
+    end
+    spec "if passed non-directory then raise error" do
+      ok_(proc { @klass.new(__FILE__) }).raise?(ArgumentError, "#{__FILE__}: not a directory.")
+    end
+    spec "if path ends with '/' then remove it" do
+      ok_(@klass.new(@cachedir + '/').root) == @cachedir
+    end
+  end
+
+  def test_filepath
+    spec "return file path for cache key" do
+      store = @klass.new(@cachedir)
+      cache_key = "obj/123[456]"
+      ok_(store.filepath(cache_key)) == "#{@cachedir}/obj/123_456_"
+    end
+  end
+
+  def test_set
+    store, key, data, fpath = @store, @key, @data, @fpath
+    spec "create directory for cache" do
+      not_ok_("#{@cachedir}/foo").exist?
+      not_ok_(fpath).exist?
+      store.set(key, data)
+      ok_("#{@cachedir}/foo").dir?
+      ok_(fpath).file?
+    end
+    spec "create temporary file and rename it to cache file (in order not to flock)" do
+      # pass
+    end
+    spec "set mtime (which is regarded as cache expired timestamp)" do
+      store.set(key, data)
+      ts = Time.now + store.lifetime
+      #ok_(File.mtime(fpath)) == ts
+      ok_(File.mtime(fpath).to_s) == ts.to_s
+      now = Time.now
+      store.set(key, data, 30)
+      now2 = Time.now
+      if now != now2
+        store.set(key, data, 30)
+        now = now2
+      end
+      #ok_(File.mtime(fpath)) == now + 30
+      ok_(File.mtime(fpath).to_s) == (now + 30).to_s
+    end
+  end
+
+  def test_get
+    store, key, data, fpath = @store, @key, @data, @fpath
+    now = Time.now
+    store.set(key, data)
+    ok_(store.filepath(key)).exist?
+    spec "if cache file is not found, return nil" do
+      ok_(store.get("kkkk")) == nil
+    end
+    spec "returns cache file content" do
+      ok_(store.get(key)) == data
+    end
+    spec "if cache file is older than original data, remove it and return nil" do
+      ok_(store.get(key, now-1)) == data # cache is newer than original
+      ok_(fpath).exist?
+      ok_(store.get(key, now+1)) == nil # cache is older than original
+      not_ok_(fpath).exist?
+    end
+    spec "if cache file is expired then remove it and return nil" do
+      store.set(key, data)
+      ok_(store.get(key)) == data   # not expired
+      ts = Time.now - 1
+      File.utime(ts, ts, fpath)            # expire cache file
+      ok_(store.get(key)) == nil
+    end
+  end
+
+  def test_del
+    store, key, data, fpath = @store, @key, @data, @fpath
+    spec "delete data file" do
+      store.set(key, data)
+      ok_(fpath).exist?
+      store.del(key)
+      not_ok_(fpath).exist?
+    end
+    spec "if data file doesn't exist, don't raise error" do
+      not_ok_(proc { store.del(key) }).raise?(Exception)
+    end
+  end
+
+  def test_has?
+    spec "if key exists then return true else return false" do
+      ok_(@store.has?(@key)) == false
+      @store.set(@key, @data)
+      ok_(@store.has?(@key)) == true
+    end
+  end
+
+
+
+end
+
+
+if __FILE__ == $0
+  Oktest.run_all()
+end

data/test/test_tcache.rb

@@ -0,0 +1,94 @@
+###
+### $Rev$
+### $Release: 0.7.0 $
+### copyright(c) 2007-2011 kuwata-lab.com all rights reserved
+###
+
+require "#{File.dirname(File.expand_path(__FILE__))}/test_all"
+
+
+class FileBaseTemplateCacheTest
+  include Oktest::TestCase
+
+  def before
+    @klass = Tenjin::FileBaseTemplateCache
+    @cache = @klass.new
+    @filepath = "_test_example.rbhtml"
+    @input = <<'END'
+<?rb #@ARGS name,  items ?>
+<p>Hello ${@name}!</p>
+<?rb for item in @items ?>
+<p>${item}</p>
+<?rb end ?>
+END
+    @script = <<'END'
+ name = @name; items = @items;
+ _buf << %Q`<p>Hello #{escape((@name).to_s)}!</p>\n`
+for item in @items
+ _buf << %Q`<p>#{escape((item).to_s)}</p>\n`
+end
+END
+    @cached = "\#@ARGS name,items\n" + @script
+    @template = Tenjin::Template.new(@filepath, :input=>@input)
+  end
+
+  def after
+    [@filepath, "#{@filepath}.cache"].each do |fpath|
+      File.unlink(fpath) if File.exist?(fpath)
+    end
+  end
+
+  def test_save
+    cachepath = @filepath + '.cache'
+    spec "save template script and args into cache file." do
+      not_ok_(cachepath).exist?
+      @cache.save(cachepath, @template)
+      ok_(cachepath).exist?
+      ok_(File.open(cachepath, 'rb') {|f| f.read }) == @cached
+    end
+    spec "set cache file's mtime to template timestamp." do
+      t = Time.now - 30
+      @template.timestamp = t
+      @cache.save(cachepath, @template)
+      ok_(File.mtime(cachepath).inspect) == t.inspect
+    end
+  end
+
+  def test_load
+    filepath  = @filepath
+    cachepath = @filepath + '.cache'
+    File.open(filepath, 'wb') {|f| f.write(@input) }
+    File.open(cachepath, 'wb') {|f| f.write(@cached) }
+    ts = nil
+    spec "load template data from cache file." do
+      ts = File.mtime(cachepath)
+      File.utime(ts-9, ts-9, filepath)
+      ret = @cache.load(cachepath, ts)
+      ok_(ret).is_a?(Array)
+      args = ['name', 'items']
+      spec "get template args data from cached data."
+      spec "return script, template args, and mtime of cache file." do
+        ok_(ret) == [@script, args, ts]
+      end
+    end
+    spec "if template timestamp is specified and different from that of cache file, return nil" do
+      File.utime(ts, ts, filepath)
+      File.utime(ts, ts, cachepath)
+      ok_(@cache.load(filepath, ts + 1)) == nil
+    end
+    spec "if cache file is not found, return nil." do
+      File.rename(cachepath, cachepath + '.bkup')
+      begin
+        ok_(@cache.load(cachepath, ts)) == nil
+      ensure
+        File.rename(cachepath + '.bkup', cachepath)
+      end
+    end
+  end
+
+end
+
+
+if __FILE__ == $0
+  Oktest.run_all()
+end