appengine-apis 0.0.2 → 0.0.3

data/lib/appengine-apis/merb-logger.rb

@@ -19,6 +19,7 @@
 # Switches the Merb Logger class to use the Google App Engine logging API.
 
 require 'merb-core/logger'
+require 'appengine-apis/apiproxy.rb'
 
 module Merb  # :nodoc:
   

data/lib/appengine-apis/sdk.rb

@@ -0,0 +1,93 @@
+#!/usr/bin/ruby1.8 -w
+#
+# Copyright:: Copyright 2009 Google Inc.
+# Original Author:: Ryan Brown (mailto:ribrdb@google.com)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'java'
+
+module AppEngine
+  
+  # Helper methods to locate the App Engine SDK and add it to the class path.
+  module SDK
+    class << self
+
+      # Tries to load the ApiProxy class.
+      def load_apiproxy
+        with_jars(%w{lib impl appengine-api.jar}) do
+          return Java.ComGoogleApphostingApi.ApiProxy
+        end
+      end
+      
+      # Tries to load the ApiProxyLocalFactory class.
+      def load_local_apiproxy_factory
+        with_jars(%w{lib shared appengine-local-runtime-shared.jar},
+                  %w{lib impl appengine-api-stubs.jar},
+                  %w{lib impl appengine-local-runtime.jar}
+                  ) do
+          return Java.ComGoogleAppengineToolsDevelopment.ApiProxyLocalFactory
+        end
+      end
+      
+      def with_jars(*jars)  # :nodoc:
+        begin
+          failed = false
+          yield
+        rescue NameError => ex
+          if failed
+            raise ex
+          else
+            failed = true
+            jars.each do |jar|
+              $CLASSPATH << sdk_path(*jar)
+            end
+            retry
+          end
+        end
+      end
+      
+      # Tries to find the Google App Engine SDK for Java.
+      #
+      # Looks for appcfg.sh in these directories (in order):
+      # - ENV['APPENGINE_JAVA_SDK']/bin
+      # - each directory in ENV['PATH']
+      # - '/usr/local/appengine-java-sdk/bin'
+      # - 'c:\appengine-java-sdk\bin'
+      #
+      # Returns File.join(sdk_directory, *pieces)
+      #
+      def sdk_path(*pieces)
+        puts "sdk_path(#{pieces.join('/')})"
+        unless @sdk_path
+          base_path = File.join(ENV['APPENGINE_JAVA_SDK'] || '', 'bin')
+          exec_paths = ENV['PATH'].split(File::PATH_SEPARATOR)
+          exec_paths << '/usr/local/appengine-java-sdk/bin'
+          exec_paths << 'c:\appengine-java-sdk\bin'
+          # TODO also check for reggae
+          
+          while !exec_paths.empty?
+            if File.exist?(File.join(base_path, 'appcfg.sh'))
+              @sdk_path = File.dirname(base_path)
+              return File.join(@sdk_path, *pieces)
+            end
+            base_path = exec_paths.shift
+          end
+          raise "Unable to locate the Google App Engine SDK for Java."
+        end
+        File.join(@sdk_path, *pieces)
+      end
+    end
+  end
+end

data/lib/appengine-apis/testing.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/ruby1.8 -w
 #
-# Copyright:: Copyright 2007 Google Inc.
+# Copyright:: Copyright 2009 Google Inc.
 # Original Author:: Ryan Brown (mailto:ribrdb@google.com)
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -31,8 +31,6 @@ module AppEngine
   # To run outside this environment, you need to install a test environment and
   # api stubs.
   module Testing
-    import com.google.appengine.tools.development.ApiProxyLocalFactory
-    import com.google.appengine.api.datastore.dev.LocalDatastoreService
 
     class TestEnv  # :nodoc:
       include AppEngine::ApiProxy::Environment
@@ -43,7 +41,9 @@ module AppEngine
       def initialize
         @appid = "test"
         @version = "1.0"
-        @auth_domain = "gmail.com"
+        @auth_domain = @request_namespace = "gmail.com"
+        @default_namespace = ""
+        @email = ""
       end
       
       def getAppId
@@ -59,7 +59,7 @@ module AppEngine
       end
       
       def isLoggedIn
-        !(@email.nil? || @auth_domain.nil?)
+        !(@email.nil? || @auth_domain.nil? || @email.empty?)
       end
       
       def isAdmin
@@ -80,7 +80,11 @@ module AppEngine
       
       def setDefaultNamespace(s)
         @default_namespace = s
-      end      
+      end
+      
+      def inspect
+        "#<TestEnv>"
+      end
     end
     
     class << self
@@ -99,7 +103,7 @@ module AppEngine
       end
       
       def factory  # :nodoc:
-        @factory ||= ApiProxyLocalFactory.new
+        @factory ||= AppEngine::SDK.load_local_apiproxy_factory.new
       end
       
       # The application directory, or '.' if not set.
@@ -124,13 +128,15 @@ module AppEngine
       def install_test_datastore
         self.app_dir = '.' if app_dir.nil?
         delegate = factory.create
+        lds = Java.ComGoogleAppengineApiDatastoreDev.LocalDatastoreService
+        
         delegate.set_property(
-            LocalDatastoreService::NO_STORAGE_PROPERTY, "true")
+            lds::NO_STORAGE_PROPERTY, "true")
         delegate.set_property(
-            LocalDatastoreService::MAX_QUERY_LIFETIME_PROPERTY,
+            lds::MAX_QUERY_LIFETIME_PROPERTY,
             java.lang.Integer::MAX_VALUE.to_s)
         delegate.set_property(
-            LocalDatastoreService::MAX_TRANSACTION_LIFETIME_PROPERTY,
+            lds::MAX_TRANSACTION_LIFETIME_PROPERTY,
             java.lang.Integer::MAX_VALUE.to_s)
         ApiProxy::setDelegate(delegate)
         delegate
@@ -149,6 +155,45 @@ module AppEngine
         delegate
       end
       
+      # Loads stub API implementations if no API implementation is
+      # currently configured.
+      #
+      # Sets up a datastore saved to disk in +app_dir+. +app_dir+ defaults
+      # to ENV['APPLICATION_ROOT'] or '.' if not specified.
+      #
+      # Does nothing is APIs are already configured (e.g. in production).
+      #
+      # As a shortcut you can use
+      #   require 'appengine-apis/local_boot'
+      # 
+      def boot(app_dir=nil)
+        app_dir ||= ENV['APPLICATION_ROOT'] || '.'
+        unless AppEngine::ApiProxy.current_environment
+          env = install_test_env
+          appid = get_app_id(app_dir)
+          env.appid = appid if appid
+        end
+        unless AppEngine::ApiProxy.delegate
+          self.app_dir = app_dir
+          install_api_stubs
+        end
+      end
+      
+      # Looks for app.yaml or WEB-INF/appengine-web.xml in +app_dir+
+      # and parses the application id.
+      def get_app_id(app_dir)
+        aeweb_path = File.join(app_dir, 'WEB-INF', 'appengine-web.xml')
+        app_yaml_path = File.join(app_dir, 'app.yaml')
+        if File.exist?(app_yaml_path)
+          app_yaml = YAML.load(File.open(app_yaml_path))
+          return app_yaml['application']
+        elsif File.exist?(aeweb_path)
+          require 'rexml/document'
+          aeweb = REXML::Document.new(File.new(aeweb_path))
+          return aeweb.root.elements['application'].text
+        end
+      end
+      
     end
 
   end

data/lib/appengine-apis/urlfetch.rb

@@ -25,6 +25,11 @@ module AppEngine
   #
   # Chunked and hanging requests are not supported, and all content will be
   # returned in a single block.
+  #
+  # URLFetch::HTTP also provides a drop-in replacement for Net::HTTP.
+  # To replace the standard implementation throughout your app you can do:
+  #   require 'appengine-apis/urlfetch'
+  #   Net::HTTP = AppEngine::URLFetch::HTTP
   module URLFetch
     import com.google.appengine.api.urlfetch.FetchOptions
     import com.google.appengine.api.urlfetch.HTTPHeader
@@ -44,12 +49,12 @@ module AppEngine
     
     module_function
     
-    #Fetches the given HTTP URL, blocking until the result is returned.
+    # Fetches the given HTTP URL, blocking until the result is returned.
     # 
     # Supported options:
     # [:method] GET, POST, HEAD, PUT, or DELETE
     # [:payload] POST or PUT payload (implies method is not GET, HEAD,
-    #           or DELETE)
+    #            or DELETE)
     # [:headers]
     #    HTTP headers to send with the request. May be a Hash or
     #    Net::HTTPHeaders.

data/spec/datastore_types_spec.rb

@@ -194,5 +194,16 @@ describe AppEngine::Datastore::Entity do
     end
     props.should == {}
   end
-    
+  
+  it "should support update" do
+    @entity.update('foo' => 'bar', 'count' => 3)
+    @entity[:foo].should == 'bar'
+    @entity[:count].should == 3
+  end
+  
+  it "should support to_hash" do
+    props = {'foo' => 'bar', 'count' => 3}
+    @entity.merge!(props)
+    @entity.to_hash.should == props
+  end
 end

data/spec/mail_spec.rb

@@ -0,0 +1,179 @@
+#!/usr/bin/ruby1.8 -w
+#
+# Copyright:: Copyright 2009 Google Inc.
+# Original Author:: Ryan Brown (mailto:ribrdb@google.com)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'appengine-apis/apiproxy'
+require 'appengine-apis/mail'
+
+MailMessage = JavaUtilities.get_proxy_or_package_under_package(
+  com.google.appengine.api.mail,
+  'MailServicePb$MailMessage'
+)
+
+describe AppEngine::Mail do
+  before :each do
+    @delegate = mock_delegate
+    AppEngine::ApiProxy.set_delegate(@delegate)
+  end
+  
+  def should_send(message)
+    should_make_call('Send', message)
+  end
+  
+  def should_send_to_admins(message)
+    should_make_call('SendToAdmins', message)
+  end
+  
+  def should_make_call(call, message)
+    @delegate.should_receive(:makeSyncCall).with(
+      anything, 'mail', call, proto(MailMessage, message))
+  end
+  
+  it "should send simple message" do
+    should_send({
+      :sender => 'ribrdb@example.com',
+      :to => ['bob@example.com'],
+      :subject => 'Howdy',
+      :text_body => 'Sup?'
+    })
+    AppEngine::Mail.send(
+      'ribrdb@example.com', 'bob@example.com',
+      'Howdy', 'Sup?')
+  end
+  
+  it "should support cc" do
+    should_send({
+      :sender => 'ribrdb@example.com',
+      :to => ['bob@example.com'],
+      :cc => ['fred@example.com'],
+      :subject => 'Howdy',
+      :text_body => 'Sup?'      
+    })
+    AppEngine::Mail.send(
+      'ribrdb@example.com', 'bob@example.com',
+      'Howdy', 'Sup?', :cc => 'fred@example.com')
+  end
+  
+  it "should support bcc" do
+    should_send({
+      :sender => 'ribrdb@example.com',
+      :to => ['bob@example.com'],
+      :bcc => ['fred@example.com'],
+      :subject => 'Howdy',
+      :text_body => 'Sup?'      
+    })
+    AppEngine::Mail.send(
+      'ribrdb@example.com', 'bob@example.com',
+      'Howdy', 'Sup?', :bcc => 'fred@example.com')
+  end
+  
+  it "should support multiple recipients" do
+    should_send({
+      :sender => 'ribrdb@example.com',
+      :to => ['bob@example.com', 'fred@example.com'],
+      :cc => ['bob@example.com', 'fred@example.com'],
+      :bcc => ['bob@example.com', 'fred@example.com'],
+      :subject => 'Howdy',
+      :text_body => 'Sup?'      
+    })
+    AppEngine::Mail.send(
+      'ribrdb@example.com', ['bob@example.com', 'fred@example.com'],
+      'Howdy', 'Sup?',
+      :cc => ['bob@example.com', 'fred@example.com'],
+      :bcc => ['bob@example.com', 'fred@example.com'])    
+  end
+  
+  it "should support no to" do
+    should_send({
+      :sender => 'ribrdb@example.com',
+      :to => [],
+      :bcc => ['fred@example.com'],
+      :subject => 'Howdy',
+      :text_body => 'Sup?'      
+    })
+    AppEngine::Mail.send(
+      'ribrdb@example.com', nil,
+      'Howdy', 'Sup?', :bcc => 'fred@example.com')
+  end
+  
+  it "should support html" do
+    should_send({
+      :sender => 'ribrdb@example.com',
+      :to => ['bob@example.com'],
+      :subject => 'Howdy',
+      :text_body => 'Sup?', 
+      :html_body => '<h1>Sup?</h1>',
+    })
+    AppEngine::Mail.send(
+      'ribrdb@example.com', 'bob@example.com',
+      'Howdy', 'Sup?', :html => '<h1>Sup?</h1>')
+  end
+  
+  it "should support html only" do
+    should_send({
+      :sender => 'ribrdb@example.com',
+      :to => ['bob@example.com'],
+      :subject => 'Howdy',
+      :html_body => '<h1>Sup?</h1>',
+    })
+    AppEngine::Mail.send(
+      'ribrdb@example.com', 'bob@example.com',
+      'Howdy', nil, :html => '<h1>Sup?</h1>')
+  end
+  
+  it "should support attachments hash" do
+    should_send({
+      :sender => 'ribrdb@example.com',
+      :to => ['bob@example.com'],
+      :subject => 'Howdy',
+      :text_body => 'Sup?',
+      :attachment => [
+        {:file_name => 'foo.gif', :data => 'foo'},
+        ]
+    })
+    AppEngine::Mail.send(
+      'ribrdb@example.com', 'bob@example.com',
+      'Howdy', 'Sup?', :attachments => {'foo.gif' => 'foo'})
+  end
+  
+  it "should support attachments list" do
+    should_send({
+      :sender => 'ribrdb@example.com',
+      :to => ['bob@example.com'],
+      :subject => 'Howdy',
+      :text_body => 'Sup?',
+      :attachment => [
+        {:file_name => 'foo.gif', :data => 'foo1'},
+        {:file_name => 'foo.gif', :data => 'foo2'},
+        ]
+    })
+    AppEngine::Mail.send(
+      'ribrdb@example.com', 'bob@example.com',
+      'Howdy', 'Sup?',
+      :attachments => [['foo.gif', 'foo1'], ['foo.gif', 'foo2']])
+  end
+  
+  it "should support sending to admins" do
+    should_send_to_admins({
+      :sender => 'ribrdb@example.com',
+      :subject => 'Howdy',
+      :text_body => 'Sup?'
+    })
+    AppEngine::Mail.send_to_admins('ribrdb@example.com', 'Howdy', 'Sup?')
+  end
+end

data/spec/memcache_spec.rb

@@ -0,0 +1,385 @@
+# Copyright:: Copyright 2009 Google Inc.
+# Original Author:: Ryan Brown (mailto:ribrdb@google.com)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'appengine-apis/memcache'
+
+describe AppEngine::Memcache do
+  before :each do
+    AppEngine::Testing::install_test_datastore
+    @cache = AppEngine::Memcache.new
+  end
+  
+  before :all do
+    AppEngine::Testing::install_test_env
+  end
+  
+  describe 'get' do
+    
+    it 'should return nil on miss' do
+      @cache.get('foobar').should == nil
+      @cache['foobar'].should == nil
+    end
+    
+    it 'should support strings' do
+      @cache.set('foobar', 'test').should == true
+      @cache.get('foobar').should == 'test'
+      @cache['foobar'].should == 'test'
+    end
+    
+    it 'should support multiple values' do
+      @cache.get('foo', 'bar', 'baz').should == [nil, nil, nil]
+      @cache['foo', 'bar', 'baz'].should == [nil, nil, nil]
+      @cache.set('bar', 'food').should == true
+      @cache['foo', 'bar', 'baz'].should == [nil, 'food', nil]
+    end
+    
+    it 'should support getting an array of keys' do
+      @cache.set('foobar', 'test').should == true
+      @cache.get(['foobar', 'flowers']).should == ['test', nil]
+      @cache.get(['foobar']).should == ['test']
+    end
+    
+    it 'should support numbers' do
+      @cache.set('one', 1).should == true
+      @cache.set('pi', 3.14).should == true
+      @cache.get('pi').should == 3.14
+      @cache.get('one').should === 1
+    end
+    
+    it 'should support symbol keys' do
+      @cache.set(:a, 'A')
+      @cache.get(:a).should == 'A'
+    end
+    
+    it 'should support booleans' do
+      @cache.set('true', true)
+      @cache.set('false', false)
+      @cache.get('true').should == true
+      @cache.get('false').should == false
+    end
+    
+    it 'should support marshaled objects' do
+      @cache.set('a', 1..5)
+      @cache.get('a').should == (1..5)
+    end
+    
+    it 'should support false keys' do
+      @cache.set(nil, 'nil')
+      @cache.set(false, 'false')
+      @cache.get(nil).should == 'nil'
+      @cache.get(false).should == 'false'
+    end
+  end
+  
+  describe 'get_hash' do
+    it 'should not include missing keys' do
+      @cache.get_hash(:a, :b).should == {}
+    end
+    
+    it 'should get objects' do
+      @cache.set('a', 'A')
+      @cache.set('b', 3)
+      @cache.get_hash('a', 'c', 'b').should == {'a' => 'A', 'b' => 3 }
+    end
+  end
+  
+  describe 'clear' do
+    it 'should clear the cache' do
+      @cache.set(:a, 'A')
+      @cache.set('b', 'B')
+      @cache.clear
+      @cache.get_hash(:a, 'b', :c).should == {}
+    end
+  end
+  
+  describe 'flush_all' do
+    it 'should clear the cache' do
+      @cache.set(:a, 'A')
+      @cache.set('b', 'B')
+      @cache.flush_all
+      @cache.get_hash(:a, 'b', :c).should == {}
+    end
+  end
+  
+  describe 'stats' do
+    it 'should count items' do
+      @cache.stats[:items].should == 0
+      @cache.set(:a, 'A')
+      @cache.stats[:items].should == 1
+    end
+  end
+
+  describe 'delete' do
+    it 'should remove items' do
+      @cache.set(:a, 'A')
+      @cache.get(:a).should == 'A'
+      @cache.delete(:a).should == true
+      @cache.get(:a).should == nil
+      @cache.get_hash(:a).should == {}
+    end
+    
+    it 'should return false on missing items' do
+      @cache.delete(:a).should == false
+    end
+    
+    it 'should allow blocking adds' do
+      @cache.set(:a, '1')
+      @cache.set(:b, '2')
+      @cache.delete(:a)
+      @cache.delete(:b, 1)
+      @cache.add(:a, 'A').should == true
+      @cache.add(:b, 'B').should == false
+    end
+  end
+  
+  describe 'delete_many' do
+    it 'should remove items' do
+      @cache.set(:a, 'A')
+      @cache.set(:b, 'B')
+      @cache.set(:c, 'C')
+      @cache.delete_many([:a, :c])
+      @cache.get_hash(:a, :b, :c).should == {:b => 'B'}
+    end
+    
+    it 'should return removed keys' do
+      @cache.set('a', 'A')
+      @cache.set('b', 'B')
+      @cache.set('c', 'C')
+      removed = @cache.delete_many(['a', 'c'])
+      removed.sort.should == ['a', 'c']
+    end
+    
+    it 'should not return missing keys' do
+      @cache.set('a', 'A')
+      @cache.set('b', 'B')
+      @cache.set('c', 'C')
+      removed = @cache.delete_many(['a', 'c', 'd', 'e'])
+      removed.sort.should == ['a', 'c']
+      @cache.delete_many(['e']).should == []
+    end
+    
+    
+    it 'should allow blocking adds' do
+      @cache.set(:a, '1')
+      @cache.set(:b, '2')
+      @cache.delete_many([:a])
+      @cache.delete([:b, :c], 1)
+      @cache.add(:a, 'A').should == true
+      @cache.add(:b, 'B').should == false
+    end
+  end
+  
+  describe 'add' do
+    it 'should add missing' do
+      @cache.add(:a, 'A').should == true
+      @cache.get(:a).should == 'A'
+    end
+    
+    it 'should not replace existing entries' do
+      @cache.set(:a, 1)
+      @cache.add(:a, 'A').should == false
+      @cache.get(:a).should == 1
+    end
+  end
+  
+  describe 'add_many' do
+    it 'should add missing' do
+      @cache.add_many({:a => 1, :b =>2})
+      @cache.get(:b, :a).should == [2, 1]
+    end
+    
+    it 'should not replace existing entries' do
+      @cache.set(:a, 1)
+      @cache.add_many({:a => 'A', :b => 'B'})
+      @cache.get(:a, :b).should == [1, 'B']
+    end
+    
+    it 'should return existing keys' do
+      @cache.set(:a, 1)
+      @cache.add_many({:a => 'A', :b => 'B'}).should == [:a]
+    end
+  end
+  
+  describe 'set' do
+    it 'should add missing' do
+      @cache.set(:a, :A).should == true
+      @cache.get(:a).should == :A
+    end
+    
+    it 'should replace existing' do
+      @cache.set(:a, :A).should == true
+      @cache.get(:a).should == :A
+      @cache.set(:a, 1).should == true
+      @cache.get(:a).should == 1
+    end
+  end
+  
+  describe 'set_many' do
+    it 'should set multiple values' do
+      @cache.set_many({:a => 1, :b => 2}).should == []
+    end
+  end
+  
+  describe 'replace' do
+    it 'should replace existing' do
+      @cache.set(:a, :A).should == true
+      @cache.get(:a).should == :A
+      @cache.replace(:a, 1).should == true
+      @cache.get(:a).should == 1
+    end
+    
+    it 'should not replace missing' do
+      @cache.replace(:a, :A).should == false
+    end
+  end
+  
+  describe 'replace_many' do
+    it 'should replace many' do
+      @cache.set_many({:a => 1, :c => 3})
+      @cache.replace_many({:a => :A, :b => :B, :c => :C}).should == [:b]
+      @cache.get(:a, :b, :c).should == [:A, nil, :C]
+    end
+  end
+  
+  describe 'dict access' do
+    it 'should support getting with []' do
+      @cache.set(:a, 7)
+      @cache[:a].should == 7
+      @cache.set(:b, :B)
+      @cache[:a, :b].should == [7, :B]
+    end
+    
+    it 'should support setting with []=' do
+      @cache[:a, :b] = [1, :B]
+      @cache[:c] = 3
+      @cache[:a].should == 1
+      @cache[:b].should == :B
+      @cache[:c].should == 3
+    end
+  end
+  
+  describe 'incr' do
+    it 'should increment number' do
+      @cache.set(:a, 1)
+      @cache.incr(:a).should == 2
+      @cache.incr(:a, 7).should == 9
+      @cache.get(:a).should == 9
+    end
+    
+    it 'should wrap' do
+      @cache.set(:a, 7)
+      @cache.incr(:a, 2**62).should == 2**62 + 7
+      @cache.incr(:a, 2**62).should < 2**62
+    end
+    
+    it 'should fail if not number' do
+      @cache.incr(:a).should == nil
+      @cache.get_hash([:a]).should == {}
+      @cache.set(:b, :foo)
+      lambda {@cache.incr(:b)}.should raise_error(
+          AppEngine::Memcache::InvalidValueError)
+    end
+    
+    it 'should increment strings' do
+      @cache.set(:a, '7')
+      @cache.incr(:a).should == 8
+    end
+  end
+  
+  describe 'decr' do
+    it 'should decrement number' do
+      @cache.set(:a, 7)
+      @cache.decr(:a).should == 6
+      @cache.get(:a).should == 6
+      @cache.decr(:a, 2).should == 4
+      @cache.get(:a).should == 4
+      @cache.decr(:a, 4).should == 0
+      @cache.get(:a).should == 0
+      pending 'local decrement wrapping' do
+        @cache.decr(:a, 6).should == 0
+        @cache.get(:a).should == 0
+      end
+    end
+  end
+  
+  describe 'readonly' do
+    before :each do
+      @rocache = AppEngine::Memcache.new(:readonly => true)
+      @ex = AppEngine::Memcache::MemcacheError
+    end
+    
+    it 'should allow reads' do
+      @cache[:a] = 1
+      @rocache.get(:a).should == 1
+    end
+    
+    it 'should allow stats' do
+      @cache[:a] = 7
+      @rocache.stats[:items].should == 1
+    end
+    
+    it 'should block delete' do
+      @cache[:a] = 1
+      lambda {@rocache.delete(:a)}.should raise_error(@ex)
+      @cache[:a].should == 1
+    end
+    
+    it 'should block add' do
+      lambda {@rocache.add(:a, 1)}.should raise_error(@ex)
+      lambda {@rocache.add_many({:b => 1})}.should raise_error(@ex)
+      @rocache.get_hash(:a, :b).should == {}
+    end
+    
+    it 'should block set' do
+      lambda {@rocache.set(:a, 1)}.should raise_error(@ex)
+      lambda {@rocache.set_many({:b => 1})}.should raise_error(@ex)
+      @rocache.get_hash(:a, :b).should == {}
+    end
+    
+    it 'should block replace' do
+      @cache[:a, :b] = :A, :B
+      lambda {@rocache.replace(:a, 1)}.should raise_error(@ex)
+      lambda {@rocache.replace_many({:b => 1})}.should raise_error(@ex)
+      @rocache[:a, :b].should == [:A, :B]
+    end
+    
+    it 'should block clear' do
+      @cache[:a] = 1
+      lambda {@rocache.clear}.should raise_error(@ex)
+      lambda {@rocache.flush_all}.should raise_error(@ex)
+      @rocache[:a].should == 1
+    end
+    
+    it 'should block incr' do
+      @cache[:a] = 1
+      lambda {@rocache.incr(:a)}.should raise_error(@ex)
+      @rocache[:a].should == 1
+    end
+    
+    it 'should block decr' do
+      @cache[:a] = 1
+      lambda {@rocache.decr(:a)}.should raise_error(@ex)
+      @rocache[:a].should == 1
+    end
+  end
+  
+  describe "namespaces" do
+    it 'should get namespace from initialize' do
+      cache = AppEngine::Memcache.new(:namespace => "foo")
+      cache.namespace.should == "foo"
+    end
+  end
+end