el 0.5.0

data/test/test__cache.rb

@@ -0,0 +1,145 @@
+module ELTest__cache
+
+  class App < E
+
+    before do
+      if key = params[:__clear_cache__]
+        key == '*' ? clear_cache! : clear_cache!(key)
+      end
+    end
+
+    def index
+    end
+
+    def heavy_io
+      cache do
+        content
+      end
+    end
+
+    def heavy_render
+      banners = cache 'banners' do
+        params[:banners] || content
+      end
+      items = cache 'items' do
+        params[:items] || content
+      end
+      [banners, items].join '/'
+    end
+
+    def clear_cache_by_regexp
+      updated = false
+      if key = params[:key]
+        clear_cache! /#{key}/
+      end
+      cache :clear_cache_by_regexp do
+        updated = true
+      end
+      updated
+    end
+
+    private
+    def content
+      ::Digest::MD5.hexdigest rand(1024**1024).to_s
+    end
+
+  end
+
+  Spec.new App do
+
+    io = get :heavy_io
+    expect(io.status) == 200
+
+    a, b = [], []
+    10.times do
+      get :heavy_io
+      a << io.body
+      b << last_response.body
+    end
+    expect(a) == b
+
+    render = get :heavy_render
+    expect(render.status) == 200
+
+    a, b = [], []
+    10.times do
+      get :heavy_render
+      a << render.body
+      b << last_response.body
+    end
+    expect(a) == b
+
+    Should 'clear ALL cache' do
+      get :__clear_cache__ => '*'
+
+      get :heavy_io
+      refute(last_response.body) == io.body
+
+      get :heavy_render
+      refute(last_response.body) == render.body
+    end
+
+    Should 'clear cache by exact match keys' do
+
+      banners, items = 2.times.map { rand.to_s }
+      Should 'clear and store new cache' do
+        get :__clear_cache__ => '*'
+
+        render = get :heavy_render, :banners => banners, :items => items
+        expect(render.body) == [banners, items].join('/')
+
+        a, b = [], []
+        10.times do
+          get :heavy_render, :banners => rand.to_s, :items => rand.to_s
+          a << render.body
+          b << last_response.body
+        end
+        expect(a) == b
+      end
+
+      new_banners, new_items = 2.times.map { rand.to_s }
+      Context 'updating banners' do
+        get :__clear_cache__ => :banners
+
+        get :heavy_render, :banners => new_banners, :items => rand.to_s
+        expect(last_response.body) == [new_banners, items].join('/')
+      end
+
+      Context 'updating items' do
+        get :__clear_cache__ => :items
+
+        get :heavy_render, :banners => rand.to_s, :items => new_items
+        expect(last_response.body) == [new_banners, new_items].join('/')
+      end
+    end
+
+    Should 'clear by given regexp' do
+
+      get :clear_cache_by_regexp
+      expect(last_response.body) == 'true'
+
+      get :clear_cache_by_regexp
+      expect(last_response.body) == 'false'
+
+      %w[
+        clear
+        cache
+        by
+        regexp
+        clear_cache
+        clear_cache_by
+        clear_cache_by_regexp
+      ].each do |key|
+        get :clear_cache_by_regexp, :key => key
+        expect(last_response.body) == 'true'
+      end
+      
+      %w[foo bar baz].each do |key|
+        get :clear_cache_by_regexp, :key => key
+        expect(last_response.body) == 'false'
+      end
+
+    end
+
+  end
+end

data/test/test__content_helpers.rb

@@ -0,0 +1,41 @@
+module ELTest__content_helpers
+
+  Spec.new self do
+    include EL::TagFactory
+    include EL::ContentHelpers
+
+    Testing :content_for do
+      content_for :assets do
+        js_tag :jquery
+      end
+
+      is(content_for? :assets).kind_of? Proc
+      is(content_for? :blah).nil?
+
+      expected_html = '<script src="jquery.js" type="text/javascript"></script>'
+      does(yield_content :assets).match? expected_html
+
+      content_for :account do |name, email|
+        form_tag! do
+          input_tag(value: name) +
+          input_tag(value: email)
+        end
+      end
+
+      expected_html = '<form><input value="foo"><input value="foo@bar.com"></form>'
+      does(yield_content :account, :foo, 'foo@bar.com').match? expected_html
+    end
+
+    Testing :capture_html do
+      html = capture_html do
+        js_tag(:jquery) +
+        css_tag(:ui)
+      end
+
+      expected_html  = '<script src="jquery.js" type="text/javascript"></script>'
+      expected_html << '<link href="ui.css" media="all" type="text/css" rel="stylesheet">'
+      does(html).match? expected_html
+    end
+
+  end
+end

data/test/test__crud.rb

@@ -0,0 +1,269 @@
+module ELTest__crud
+
+  class Resource
+
+    attr_reader :objects
+
+    def initialize
+      @objects = {}
+    end
+
+    def get id
+      @objects[id.to_i]
+    end
+
+    def create object
+      if obj_id = object.delete('id')
+        object[:id] = obj_id.to_i
+      end
+      id = @objects.size + 1
+      def object.destroy
+        self['__objects__'].delete self['__id__']
+      end
+      @objects[id] = object.update('__objects__' => @objects, '__id__' => id)
+    end
+
+    def [] key
+      @objects[key.to_i]
+    end
+
+    def keys
+      @objects.keys
+    end
+  end
+
+  class ResourceWithErrors < Resource
+    def create object
+      id = (@objects.size + 1).to_s
+      @objects[id] = HashWithErrors[object.merge('__id__' => id)]
+    end
+
+    class HashWithErrors < Hash
+      def errors
+        error = 'someErrorOccurred'
+        # alternating returned error type 
+        # cause various resources may throw errors of various types
+        rand(1000) % 2 == 0 ? 
+          [error]           :
+          rand(1000) % 2 == 0 ? {:error => [error]} : error
+      end
+    end
+  end
+
+  RESOURCE = Resource.new
+  PRIVATE_RESOURCE = Resource.new
+
+  class App < E
+    map '/'
+
+    crudifier = lambda do |obj|
+      case
+        when rq.post?, rq.put?, rq.patch?
+          obj && obj['__id__']
+        when rq.head?
+          response.headers['Last-Modified'] = params[:lm]
+        else
+          obj.inspect
+      end
+    end
+
+    crudify RESOURCE, :exclude => ['excluded_param', 'skip_this'], &crudifier
+    crudify PRIVATE_RESOURCE, :private, &crudifier
+
+    setup :post_private, :put_private, :patch_private, :delete_private do
+      auth do |u, p|
+        [u, p] == ['user', 'pass']
+      end
+    end
+  end
+
+  Spec.new App do
+
+    def update request_method
+      lambda do
+        key    = RESOURCE.keys.last
+        record = RESOURCE[key].dup
+        name   = rand.to_s
+
+        send request_method, key, :name => name, :excluded_param => 'blah', :skip_this => 'doh'
+
+        updated_record = RESOURCE[last_response.body]
+        expect(updated_record).is_a? Hash
+        refute(updated_record['name']) == record['name']
+        is(updated_record['excluded_param']).nil?
+        is(updated_record['skip_this']).nil?
+      end
+    end
+
+    Testing :public_CRUD do
+      map App.base_url
+
+      Test 'create and update' do
+        Should 'create new records' do
+          0.upto(5).each do
+            name = rand.to_s
+            rsp = post :name => name
+            id = rsp.body
+            is(id.to_i) > 0
+          end
+
+          And 'update last record by PUT', &update(:put)
+          And 'update last record by PATCH', &update(:patch)
+        end
+      end
+
+      Test :get do
+        RESOURCE.keys.each do |key|
+          get key
+          expect(last_response.body) =~ /"name"=>"#{RESOURCE[key]['name']}"/
+        end
+      end
+
+      Test :head do
+        RESOURCE.keys.each do |key|
+          last_modified = Time.now.rfc2822.to_s
+          rsp = head key, :lm => last_modified
+          expect(rsp.body) == ''
+          expect(rsp.header['Last-Modified']) == last_modified
+        end
+      end
+
+      Test :delete do
+        RESOURCE.keys.each do |key|
+          delete key
+          expect(last_response.status) == 200
+        end
+        expect(RESOURCE.keys.size) == 0
+      end
+
+      Test :options do
+        rsp = options
+        expect(rsp.body) == 'GET, POST, PUT, HEAD, DELETE, OPTIONS, PATCH, TRACE'
+      end
+
+    end
+
+    Testing :private_CRUD do
+
+      map App.route :private
+
+      Test :options do
+        rsp = options
+        expect(rsp.body) == 'GET, HEAD, OPTIONS, TRACE'
+
+        authorize 'user', 'pass'
+        rsp = options
+        expect(rsp.body) == 'GET, POST, PUT, HEAD, DELETE, OPTIONS, PATCH, TRACE'
+      end
+
+      reset_app!
+
+      Should 'require authorization on C/U/D' do
+
+        rsp = post
+        expect(rsp.status) == 401
+
+        rsp = put rand
+        expect(rsp.status) == 401
+
+        rsp = patch rand
+        expect(rsp.status) == 401
+
+        rsp = delete rand
+        expect(rsp.status) == 401
+
+      end
+
+      Should 'grant access and create items' do
+
+        authorize 'user', 'pass'
+
+        Should 'create an item' do
+          name = rand.to_s
+          rsp = post :name => name
+          id = rsp.body
+          is(id.to_i) > 0
+
+          Then 'update created item' do
+            new_name = rand.to_s
+            patch id, :name => new_name
+
+            get id
+            refute(last_response.body) =~ /"name"=>"#{name}"/
+            expect(last_response.body) =~ /"name"=>"#{new_name}"/
+
+            And 'finally delete it' do
+              delete id
+              expect(last_response.status) == 200
+              is(PRIVATE_RESOURCE.keys).empty?
+            end
+
+          end
+        end
+      end
+
+    end
+  end
+
+  class DefaultPrimaryKey < E
+    map :/
+
+    crudify Resource.new
+  end
+
+  class CustomPrimaryKey < E
+    map :/
+
+    crudify Resource.new, :pkey => 'obj_id'
+  end
+
+  class BuiltinErrorHandler < E
+    map :/
+
+    crudify ResourceWithErrors.new
+  end
+
+  class BuiltinErrorHandlerWithCustomStatusCode < E
+    map :/
+
+    crudify ResourceWithErrors.new, :halt_with => 501
+  end
+
+  Spec.new self do
+
+    Testing DefaultPrimaryKey do
+      app DefaultPrimaryKey.mount
+
+      obj_id = rand(1000).to_s
+      post :id => obj_id
+      expect(last_response.status) == 200
+      check(last_response.body) == obj_id
+    end
+
+    Testing CustomPrimaryKey do
+      app CustomPrimaryKey.mount
+
+      obj_id = rand(1000).to_s
+      post :obj_id => obj_id
+      expect(last_response.status) == 200
+      check(last_response.body) == obj_id
+    end
+
+    Testing BuiltinErrorHandler do
+      app BuiltinErrorHandler.mount
+
+      post :foo => :bar
+      is(last_response.status) == 500
+      does(last_response.body) =~ /someErrorOccurred/
+    end
+
+    Testing BuiltinErrorHandlerWithCustomStatusCode do
+      app BuiltinErrorHandlerWithCustomStatusCode.mount
+      
+      post :foo => :bar
+      is(last_response.status) == 501
+      expect(last_response.body) =~ /someErrorOccurred/
+    end
+  end
+
+end