moneta 1.5.2 → 1.6.0

data/spec/moneta/proxies/transformer/transformer_value_marshal_spec.rb

@@ -1,19 +0,0 @@
-describe 'transformer_value_marshal', proxy: :Transformer do
-  moneta_build do
-    Moneta.build do
-      use :Transformer, value: :marshal
-      adapter :Memory
-    end
-  end
-
-  moneta_loader do |value|
-    ::Marshal.load(value)
-  end
-
-  moneta_specs TRANSFORMER_SPECS.with_each_key
-
-  it 'compile transformer class' do
-    store.should_not be_nil
-    Moneta::Transformer::MarshalValue.should_not be_nil
-  end
-end

data/spec/moneta/proxies/transformer/transformer_value_yaml_spec.rb

@@ -1,19 +0,0 @@
-describe 'transformer_value_yaml', proxy: :Transformer do
-  moneta_build do
-    Moneta.build do
-      use :Transformer, value: :yaml
-      adapter :Memory
-    end
-  end
-
-  moneta_loader do |value|
-    ::YAML.load(value)
-  end
-
-  moneta_specs TRANSFORMER_SPECS.with_each_key
-
-  it 'compile transformer class' do
-    store.should_not be_nil
-    Moneta::Transformer::YamlValue.should_not be_nil
-  end
-end

data/spec/moneta/proxies/transformer/transformer_yaml_spec.rb

@@ -1,19 +0,0 @@
-describe 'transformer_yaml', proxy: :Transformer do
-  moneta_build do
-    Moneta.build do
-      use :Transformer, key: :yaml, value: :yaml
-      adapter :Memory
-    end
-  end
-
-  moneta_loader do |value|
-    ::YAML.load(value)
-  end
-
-  moneta_specs TRANSFORMER_SPECS.with_each_key
-
-  it 'compile transformer class' do
-    store.should_not be_nil
-    Moneta::Transformer::YamlKeyYamlValue.should_not be_nil
-  end
-end

data/spec/moneta/proxies/transformer/transformer_zlib_spec.rb

@@ -1,19 +0,0 @@
-describe 'transformer_zlib', proxy: :Transformer do
-  moneta_build do
-    Moneta.build do
-      use :Transformer, value: :zlib
-      adapter :Memory
-    end
-  end
-
-  moneta_loader do |value|
-    ::Zlib::Inflate.inflate(value)
-  end
-
-  moneta_specs TRANSFORMER_SPECS.stringvalues_only.with_each_key
-
-  it 'compile transformer class' do
-    store.should_not be_nil
-    Moneta::Transformer::ZlibValue.should_not be_nil
-  end
-end

data/spec/moneta/proxies/weak_create/weak_create_spec.rb

@@ -1,21 +0,0 @@
-describe 'weak_create', proxy: :WeakCreate do
-  before :all do
-    require 'fog/aws'
-
-    # Put Fog into testing mode
-    Fog.mock!
-  end
-
-  moneta_build do
-    Moneta.build do
-      use :WeakCreate
-      adapter :Fog,
-              aws_access_key_id: 'fake_access_key_id',
-              aws_secret_access_key: 'fake_secret_access_key',
-              provider: 'AWS',
-              dir: 'weak_create'
-    end
-  end
-
-  moneta_specs ADAPTER_SPECS.without_increment.without_concurrent.returnsame
-end

data/spec/moneta/proxies/weak_each_key/weak_each_key_spec.rb

@@ -1,22 +0,0 @@
-describe 'weak_each_key', proxy: :WeakEachKey do
-  before :all do
-    require 'fog/aws'
-
-    # Put Fog into testing mode
-    Fog.mock!
-  end
-
-  moneta_build do
-    Moneta.build do
-      use :WeakEachKey
-
-      adapter :Fog,
-              aws_access_key_id: 'fake_access_key_id',
-              aws_secret_access_key: 'fake_secret_access_key',
-              provider: 'AWS',
-              dir: 'weak_each_key'
-    end
-  end
-
-  moneta_specs ADAPTER_SPECS.with_each_key.without_create.without_increment.without_concurrent.returnsame
-end

data/spec/moneta/proxies/weak_increment/weak_increment_spec.rb

@@ -1,21 +0,0 @@
-describe 'weak_increment', proxy: :WeakIncrement do
-  before :all do
-    require 'fog/aws'
-
-    # Put Fog into testing mode
-    Fog.mock!
-  end
-
-  moneta_build do
-    Moneta.build do
-      use :WeakIncrement
-      adapter :Fog,
-              aws_access_key_id: 'fake_access_key_id',
-              aws_secret_access_key:  'fake_secret_access_key',
-              provider:               'AWS',
-              dir:                    'weak_increment'
-    end
-  end
-
-  moneta_specs ADAPTER_SPECS.without_create.without_concurrent.returnsame
-end

data/spec/moneta/semaphore_spec.rb

@@ -1,68 +0,0 @@
-describe "semaphore" do
-  moneta_store :Memory
-
-  it 'should have #lock' do
-    mutex = Moneta::Semaphore.new(store, 'semaphore')
-    mutex.lock.should be true
-    mutex.locked?.should be true
-    expect do
-      mutex.lock
-    end.to raise_error(RuntimeError)
-    expect do
-      mutex.try_lock
-    end.to raise_error(RuntimeError)
-    mutex.unlock.should be_nil
-    mutex.locked?.should be false
-  end
-
-  it 'should have #enter' do
-    mutex = Moneta::Semaphore.new(store, 'semaphore')
-    mutex.enter.should be true
-    mutex.locked?.should be true
-    expect do
-      mutex.enter
-    end.to raise_error(RuntimeError)
-    expect do
-      mutex.try_enter
-    end.to raise_error(RuntimeError)
-    mutex.leave.should be_nil
-    mutex.locked?.should be false
-  end
-
-  it 'should lock with #lock' do
-    a = Moneta::Semaphore.new(store, 'semaphore')
-    b = Moneta::Semaphore.new(store, 'semaphore')
-    a.lock.should be true
-    b.try_lock.should be false
-    a.unlock.should be_nil
-  end
-
-  it 'should have lock timeout' do
-    a = Moneta::Semaphore.new(store, 'semaphore')
-    b = Moneta::Semaphore.new(store, 'semaphore')
-    a.lock.should be true
-    b.lock(1).should be false
-    a.unlock.should be_nil
-  end
-
-  it 'should count concurrent accesses' do
-    a = Moneta::Semaphore.new(store, 'semaphore', 2)
-    b = Moneta::Semaphore.new(store, 'semaphore', 2)
-    c = Moneta::Semaphore.new(store, 'semaphore', 2)
-    a.synchronize do
-      a.locked?.should be true
-      b.synchronize do
-        b.locked?.should be true
-        c.try_lock.should be false
-      end
-    end
-  end
-
-  it 'should have #synchronize' do
-    semaphore = Moneta::Semaphore.new(store, 'semaphore')
-    semaphore.synchronize do
-      semaphore.locked?.should be true
-    end
-    semaphore.locked?.should be false
-  end
-end

data/spec/moneta/stack_file_memory_spec.rb

@@ -1,15 +0,0 @@
-describe "stack_file_memory" do
-  moneta_build do
-    tempdir = self.tempdir
-    Moneta.build do
-      use(:Stack) do
-        add(Moneta.new(:Null))
-        add(Moneta::Adapters::Null.new)
-        add { adapter :File, dir: File.join(tempdir, "stack_file_memory") }
-        add { adapter :Memory }
-      end
-    end
-  end
-
-  moneta_specs ADAPTER_SPECS.without_increment.without_create
-end

data/spec/moneta/stack_memory_file_spec.rb

@@ -1,13 +0,0 @@
-describe "stack_memory_file" do
-  moneta_build do
-    tempdir = self.tempdir
-    Moneta.build do
-      use(:Stack) do
-        add { adapter :Memory }
-        add { adapter :File, dir: File.join(tempdir, "stack_memory_file") }
-      end
-    end
-  end
-
-  moneta_specs ADAPTER_SPECS.returnsame
-end

data/spec/rack/cache_moneta_spec.rb

@@ -1,355 +0,0 @@
-require 'rack/cache/moneta'
-require 'rack/mock'
-require 'rack/cache'
-
-class Object
-  def sha_like?
-    length == 40 && self =~ /^[0-9a-z]+$/
-  end
-end
-
-describe Rack::Cache::MetaStore::Moneta do
-  before do
-    Rack::Cache::Moneta['meta'] = Moneta.new(:Memory, :expires => true)
-    Rack::Cache::Moneta['entity'] = Moneta.new(:Memory, :expires => true)
-    @store        = Rack::Cache::MetaStore::Moneta.resolve   uri('moneta://entity')
-    @entity_store = Rack::Cache::EntityStore::Moneta.resolve uri('moneta://meta')
-    @request  = mock_request('/', {})
-    @response = mock_response(200, {}, ['hello world'])
-  end
-
-  after do
-    Rack::Cache::Moneta['meta'].clear
-    Rack::Cache::Moneta['entity'].clear
-  end
-
-  it "has the class referenced by homonym constant" do
-    Rack::Cache::MetaStore::MONETA.should == Rack::Cache::MetaStore::Moneta
-  end
-
-  it "instantiates the store" do
-    @store.should be_kind_of(Rack::Cache::MetaStore::Moneta)
-  end
-
-  it "resolves the connection uri" do
-    Rack::Cache::MetaStore::Moneta.resolve(uri('moneta://Memory?expires=true')).should be_kind_of(Rack::Cache::MetaStore::Moneta)
-  end
-
-  # Low-level implementation methods ===========================================
-
-  it 'writes a list of negotation tuples with #write' do
-    # lambda {
-    @store.write('/test', [[{}, {}]])
-    # }.should_not raise Exception
-  end
-
-  it 'reads a list of negotation tuples with #read' do
-    @store.write('/test', [[{},{}],[{},{}]])
-    tuples = @store.read('/test')
-    tuples.should == [ [{},{}], [{},{}] ]
-  end
-
-  it 'reads an empty list with #read when nothing cached at key' do
-    @store.read('/nothing').should be_empty
-  end
-
-  it 'removes entries for key with #purge' do
-    @store.write('/test', [[{},{}]])
-    @store.read('/test').should_not be_empty
-
-    @store.purge('/test')
-    @store.read('/test').should be_empty
-  end
-
-  it 'succeeds when purging non-existing entries' do
-    @store.read('/test').should be_empty
-    @store.purge('/test')
-  end
-
-  it 'returns nil from #purge' do
-    @store.write('/test', [[{},{}]])
-    @store.purge('/test').should be_nil
-    @store.read('/test').should == []
-  end
-
-  %w[/test http://example.com:8080/ /test?x=y /test?x=y&p=q].each do |key|
-    it "can read and write key: '#{key}'" do
-      # lambda {
-      @store.write(key, [[{},{}]])
-      # }.should_not raise Exception
-      @store.read(key).should == [[{},{}]]
-    end
-  end
-
-  it "can read and write fairly large keys" do
-    key = "b" * 4096
-    # lambda {
-    @store.write(key, [[{},{}]])
-    # }.should_not raise Exception
-    @store.read(key).should == [[{},{}]]
-  end
-
-  it "allows custom cache keys from block" do
-    request = mock_request('/test', {})
-    request.env['rack-cache.cache_key'] =
-      lambda { |request| request.path_info.reverse }
-    @store.cache_key(request).should == 'tset/'
-  end
-
-  it "allows custom cache keys from class" do
-    request = mock_request('/test', {})
-    request.env['rack-cache.cache_key'] = Class.new do
-      def self.call(request); request.path_info.reverse end
-    end
-    @store.cache_key(request).should == 'tset/'
-  end
-
-  it 'does not blow up when given a non-marhsalable object with an ALL_CAPS key' do
-    store_simple_entry('/bad', { 'SOME_THING' => Proc.new {} })
-  end
-
-  # Abstract methods ===========================================================
-
-  it 'stores a cache entry' do
-    cache_key = store_simple_entry
-    @store.read(cache_key).should_not be_empty
-  end
-
-  it 'sets the X-Content-Digest response header before storing' do
-    cache_key = store_simple_entry
-    req, res = @store.read(cache_key).first
-    res['X-Content-Digest'].should == 'a94a8fe5ccb19ba61c4c0873d391e987982fbbd3'
-  end
-
-  it 'finds a stored entry with #lookup' do
-    store_simple_entry
-    response = @store.lookup(@request, @entity_store)
-    response.should_not be_nil
-    response.should be_kind_of(Rack::Cache::Response)
-  end
-
-  it 'does not find an entry with #lookup when none exists' do
-    req = mock_request('/test', {'HTTP_FOO' => 'Foo', 'HTTP_BAR' => 'Bar'})
-    @store.lookup(req, @entity_store).should be_nil
-  end
-
-  it "canonizes urls for cache keys" do
-    store_simple_entry(path='/test?x=y&p=q')
-
-    hits_req = mock_request(path, {})
-    miss_req = mock_request('/test?p=x', {})
-
-    @store.lookup(hits_req, @entity_store).should_not be_nil
-    @store.lookup(miss_req, @entity_store).should be_nil
-  end
-
-  it 'does not find an entry with #lookup when the body does not exist' do
-    store_simple_entry
-    @response.headers['X-Content-Digest'].should_not be_nil
-    @entity_store.purge(@response.headers['X-Content-Digest'])
-    @store.lookup(@request, @entity_store).should be_nil
-  end
-
-  it 'restores response headers properly with #lookup' do
-    store_simple_entry
-    response = @store.lookup(@request, @entity_store)
-    response.headers.should == @response.headers.merge('Content-Length' => '4')
-  end
-
-  it 'restores response body from entity store with #lookup' do
-    store_simple_entry
-    response = @store.lookup(@request, @entity_store)
-    body = '' ; response.body.each {|p| body << p}
-    body.should == 'test'
-  end
-
-  it 'invalidates meta and entity store entries with #invalidate' do
-    store_simple_entry
-    @store.invalidate(@request, @entity_store)
-    response = @store.lookup(@request, @entity_store)
-    response.should be_kind_of(Rack::Cache::Response)
-    response.should_not be :fresh?
-  end
-
-  it 'succeeds quietly when #invalidate called with no matching entries' do
-    req = mock_request('/test', {})
-    @store.invalidate(req, @entity_store)
-    @store.lookup(@request, @entity_store).should be_nil
-  end
-
-  # Vary =======================================================================
-
-  it 'does not return entries that Vary with #lookup' do
-    req1 = mock_request('/test', {'HTTP_FOO' => 'Foo', 'HTTP_BAR' => 'Bar'})
-    req2 = mock_request('/test', {'HTTP_FOO' => 'Bling', 'HTTP_BAR' => 'Bam'})
-    res = mock_response(200, {'Vary' => 'Foo Bar'}, ['test'])
-    @store.store(req1, res, @entity_store)
-
-    @store.lookup(req2, @entity_store).should be_nil
-  end
-
-  it 'stores multiple responses for each Vary combination' do
-    req1 = mock_request('/test', {'HTTP_FOO' => 'Foo',   'HTTP_BAR' => 'Bar'})
-    res1 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 1'])
-    key = @store.store(req1, res1, @entity_store)
-
-    req2 = mock_request('/test', {'HTTP_FOO' => 'Bling', 'HTTP_BAR' => 'Bam'})
-    res2 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 2'])
-    @store.store(req2, res2, @entity_store)
-
-    req3 = mock_request('/test', {'HTTP_FOO' => 'Baz',   'HTTP_BAR' => 'Boom'})
-    res3 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 3'])
-    @store.store(req3, res3, @entity_store)
-
-    slurp(@store.lookup(req3, @entity_store).body).should == 'test 3'
-    slurp(@store.lookup(req1, @entity_store).body).should == 'test 1'
-    slurp(@store.lookup(req2, @entity_store).body).should == 'test 2'
-
-    @store.read(key).length.should == 3
-  end
-
-  it 'overwrites non-varying responses with #store' do
-    req1 = mock_request('/test', {'HTTP_FOO' => 'Foo',   'HTTP_BAR' => 'Bar'})
-    res1 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 1'])
-    key = @store.store(req1, res1, @entity_store)
-    slurp(@store.lookup(req1, @entity_store).body).should == 'test 1'
-
-    req2 = mock_request('/test', {'HTTP_FOO' => 'Bling', 'HTTP_BAR' => 'Bam'})
-    res2 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 2'])
-    @store.store(req2, res2, @entity_store)
-    slurp(@store.lookup(req2, @entity_store).body).should == 'test 2'
-
-    req3 = mock_request('/test', {'HTTP_FOO' => 'Foo',   'HTTP_BAR' => 'Bar'})
-    res3 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 3'])
-    @store.store(req3, res3, @entity_store)
-    slurp(@store.lookup(req1, @entity_store).body).should == 'test 3'
-
-    @store.read(key).length.should == 2
-  end
-
-  private
-  def mock_request(uri, opts)
-    env = Rack::MockRequest.env_for(uri, opts || {})
-    Rack::Cache::Request.new(env)
-  end
-
-  def mock_response(status, headers, body)
-    headers ||= {}
-    body = Array(body).compact
-    Rack::Cache::Response.new(status, headers, body)
-  end
-
-  def slurp(body)
-    buf = ''
-    body.each { |part| buf << part }
-    buf
-  end
-
-  # Stores an entry for the given request args, returns a url encoded cache key
-  # for the request.
-  def store_simple_entry(*request_args)
-    path, headers = request_args
-    @request = mock_request(path || '/test', headers || {})
-    @response = mock_response(200, {'Cache-Control' => 'max-age=420'}, ['test'])
-    body = @response.body
-    cache_key = @store.store(@request, @response, @entity_store)
-    @response.body.should == body
-    cache_key
-  end
-
-  def uri(uri)
-    URI.parse uri
-  end
-end
-
-describe Rack::Cache::EntityStore::Moneta do
-  before do
-    @store = Rack::Cache::EntityStore::Moneta.resolve(uri('moneta://Memory?expires=true'))
-  end
-
-  it 'has the class referenced by homonym constant' do
-    Rack::Cache::EntityStore::MONETA.should == Rack::Cache::EntityStore::Moneta
-  end
-
-  it 'resolves the connection uri' do
-    Rack::Cache::EntityStore::Moneta.resolve(uri('moneta://Memory?expires=true')).should be_kind_of(Rack::Cache::EntityStore::Moneta)
-  end
-
-  it 'responds to all required messages' do
-    %w[read open write exist?].each do |message|
-      @store.should respond_to message
-    end
-  end
-
-  it 'stores bodies with #write' do
-    key, size = @store.write(['My wild love went riding,'])
-    key.should_not be_nil
-    key.should be_sha_like
-
-    data = @store.read(key)
-    data.should == 'My wild love went riding,'
-  end
-
-  it 'takes a ttl parameter for #write' do
-    key, size = @store.write(['My wild love went riding,'], 0)
-    key.should_not be_nil
-    key.should be_sha_like
-
-    data = @store.read(key)
-    data.should == 'My wild love went riding,'
-  end
-
-  it 'correctly determines whether cached body exists for key with #exist?' do
-    key, size = @store.write(['She rode to the devil,'])
-    @store.exist?(key).should be true
-    @store.exist?('938jasddj83jasdh4438021ksdfjsdfjsdsf').should be false
-  end
-
-  it 'can read data written with #write' do
-    key, size = @store.write(['And asked him to pay.'])
-    data = @store.read(key)
-    data.should == 'And asked him to pay.'
-  end
-
-  it 'gives a 40 character SHA1 hex digest from #write' do
-    key, size = @store.write(['she rode to the sea;'])
-    key.should_not be_nil
-    key.length.should == 40
-    key.should match(/^[0-9a-z]+$/)
-    key.should == '90a4c84d51a277f3dafc34693ca264531b9f51b6'
-  end
-
-  it 'returns the entire body as a String from #read' do
-    key, size = @store.write(['She gathered together'])
-    @store.read(key).should == 'She gathered together'
-  end
-
-  it 'returns nil from #read when key does not exist' do
-    @store.read('87fe0a1ae82a518592f6b12b0183e950b4541c62').should be_nil
-  end
-
-  it 'returns a Rack compatible body from #open' do
-    key, size = @store.write(['Some shells for her hair.'])
-    body = @store.open(key)
-    body.should respond_to :each
-    buf = ''
-    body.each { |part| buf << part }
-    buf.should == 'Some shells for her hair.'
-  end
-
-  it 'returns nil from #open when key does not exist' do
-    @store.open('87fe0a1ae82a518592f6b12b0183e950b4541c62').should be_nil
-  end
-
-  it 'deletes stored entries with #purge' do
-    key, size = @store.write(['My wild love went riding,'])
-    @store.purge(key).should be_nil
-    @store.read(key).should be_nil
-  end
-
-  private
-
-  def uri(uri)
-    URI.parse uri
-  end
-end

data/spec/rack/moneta_cookies_spec.rb

@@ -1,83 +0,0 @@
-require 'helper'
-require 'rack/mock'
-require 'rack/moneta_cookies'
-
-describe Rack::MonetaCookies do
-  def config(options={},&block)
-    @options = options
-    @block = block
-  end
-
-  def app(&block)
-    @app_block ||= block
-  end
-
-  def backend
-    Rack::MockRequest.new(Rack::MonetaCookies.new(lambda do |env|
-      @store = env['rack.request.cookie_hash']
-      expect(@store).to equal(env['rack.moneta_cookies'])
-      app.call(env) if app
-      [200,{},[]]
-    end, @options || {}, &@block))
-  end
-
-  def get(cookies = {}, &block)
-    app(&block)
-    @response = backend.get('/','HTTP_COOKIE' => Rack::Utils.build_query(cookies))
-  end
-
-  it 'should be able to read a key' do
-    get 'key' => 'value' do
-      expect( @store['key'] ).to eql('value')
-    end
-  end
-
-  it 'should be able to set a key' do
-    get do
-      @store['key'] = 'value'
-    end
-    expect( @response['Set-Cookie'] ).to eql('key=value')
-  end
-
-  it 'should be able to remove a key' do
-    get 'key' => 'value' do
-      @store.delete('key')
-    end
-    expect( @response['Set-Cookie'] ).to match(/key=;/)
-    expect( @response['Set-Cookie'] ).to match(/\s+expires=.*?1970/)
-  end
-
-  it 'should accept a config block' do
-    config do
-      use :Transformer, :key => :prefix, :prefix => 'moneta.'
-      adapter :Cookie
-    end
-    get 'moneta.key' => 'right', 'key' => 'wrong' do
-      expect( @store['key'] ).to eql('right')
-    end
-  end
-
-  it 'should accept a :domain option' do
-    config :domain => 'example.com'
-    get do
-      @store['key'] = 'value'
-    end
-    expect(@response['Set-Cookie']).to eql('key=value; domain=example.com')
-  end
-
-  it 'should accept a :path option' do
-    config :path => '/path'
-    get do
-      @store['key'] = 'value'
-    end
-    expect(@response['Set-Cookie']).to eql('key=value; path=/path')
-  end
-
-  it 'should be accessible via Rack::Request' do
-    get 'key' => 'value' do |env|
-      req = Rack::Request.new(env)
-      expect(req.cookies['key']).to eql('value')
-    end
-  end
-
-end