appengine-apis 0.0.1 → 0.0.2

data/History.txt

@@ -1,3 +1,7 @@
+== 0.0.2 2009-04-15
+
+* Add URLFetch and Users APIs
+
 == 0.0.1 2009-04-02
 
 * Initial release

data/Manifest.txt

@@ -10,6 +10,8 @@ lib/appengine-apis/datastore_types.rb
 lib/appengine-apis/logger.rb
 lib/appengine-apis/merb-logger.rb
 lib/appengine-apis/testing.rb
+lib/appengine-apis/urlfetch.rb
+lib/appengine-apis/users.rb
 script/console
 script/destroy
 script/generate
@@ -18,4 +20,6 @@ spec/datastore_types_spec.rb
 spec/logger_spec.rb
 spec/spec.opts
 spec/spec_helper.rb
+spec/urlfetch_spec.rb
+spec/users_spec.rb
 tasks/rspec.rake

data/README.rdoc

@@ -6,6 +6,16 @@
 
 APIs and utilities for using JRuby on Google App Engine.
 
+See these classes for an overview of each API:
+- AppEngine::Logger
+- AppEngine::Testing
+- AppEngine::Users
+- AppEngine::URLFetch
+- AppEngine::Datastore
+
+Unless you're implementing your own ORM, you probably want to use the
+DataMapper API instead of the lower level AppEngine::Datastore API.
+
 == REQUIREMENTS:
 
 * Google App Engine SDK for Java (http://code.google.com/appengine)

data/lib/appengine-apis.rb

@@ -19,5 +19,5 @@ $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 module AppEngine
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/lib/appengine-apis/datastore.rb

@@ -29,12 +29,12 @@ require 'appengine-apis/datastore_types'
 
 module AppEngine
   
-# The +Datastore+ provides access to a schema-less data
+# The Datastore provides access to a schema-less data
 # storage system.  The fundamental unit of data in this system is the
-# +Entity+, which has an immutable identity (represented by a
-# +Key+) and zero of more mutable properties.  +Entity+
+# Datastore::Entity, which has an immutable identity (represented by a
+# Datastore::Key) and zero of more mutable properties.  Entity
 # objects can be created, updated, deleted, retrieved by identifier,
-# and queried via a combination of properties.
+# and queried via a combination of properties using Datastore::Query.
 #
 # The +Datastore+ can be used transactionally and supports the
 # notion of a "current" transaction.  A current transaction is established by
@@ -47,6 +47,21 @@ module AppEngine
 # Users of this class have the choice of explicitly passing a (potentially
 # null) +Transaction+ to these methods or relying on the current transaction.
 #
+# Supported property types:
+# - String (max 500 chars)
+# - Integer ((-2**63)..(2**63 - 1))
+# - Float
+# - Time
+# - TrueClass
+# - FalseClass
+# - NilClass
+# - Datastore::Key
+# - Datastore::Link
+# - Datastore::Text
+# - Datastore::Blob
+# - Datastore::ByteString
+# - com.google.appengine.api.users.User
+
 module Datastore
   module_function
   
@@ -254,11 +269,14 @@ module Datastore
     FetchOptions = JavaDatastore::FetchOptions
     
     module Constants
-      [JQuery::FilterOperator, JQuery::SortDirection].each do |enum|
-        enum.constants.each do |name|
-          const_set(name, enum.const_get(name))
-        end
-      end
+      EQUAL = JQuery::FilterOperator::EQUAL
+      GREATER_THAN = JQuery::FilterOperator::GREATER_THAN
+      GREATER_THAN_OR_EQUAL = JQuery::FilterOperator::GREATER_THAN_OR_EQUAL
+      LESS_THAN = JQuery::FilterOperator::LESS_THAN
+      LESS_THAN_OR_EQUAL = JQuery::FilterOperator::LESS_THAN_OR_EQUAL
+      
+      ASCENDING = JQuery::SortDirection::ASCENDING
+      DESCENDING = JQuery::SortDirection::DESCENDING
     end
     include Constants
     

data/lib/appengine-apis/datastore_types.rb

@@ -35,20 +35,42 @@ module AppEngine
   module Datastore
     JavaDatastore = Java.ComGoogleAppengineApiDatastore
     
+    # Base class of Datastore Errors
     class Error < StandardError; end
+    
+    # Raised when a query requires a Composite index that does not exist
     class NeedIndex < Error; end
+    
+    # The datastore operation timed out. This can happen when you attempt to
+    # put, get, or delete too many entities or an entity with too many
+    # properties, or if the datastore is overloaded or having trouble.
     class Timeout < Error; end
+    
+    # An internal datastore error. Please report this to Google.
     class InternalError < Error; end
+    
+    # May be raised during a call to #transaction to abort and rollback the
+    # transaction. Note that *any* exception raised by a transaction
+    # block will cause a rollback. This is purely for convenience.
     class Rollback < Error; end
+    
+    # Raised when a transaction could not be committed, usually due to
+    # contention.
     class TransactionFailed < Error; end
+    
+    # Raised by #get when the requested entity is not found.
     class EntityNotFound < Error; end
+    
+    # Raised by Datastore::Query.entity if the query returns more
+    # than one entity
     class TooManyResults < Error; end
     
-    #A long string type.
+    # A long string type.
     # 
     # Strings of any length can be stored in the datastore using this
     # type.
     #
+    # Not indexed.
     class Text < String
       def to_java
         JavaDatastore::Text.new(self.to_java_string)
@@ -60,6 +82,7 @@ module AppEngine
     end
     
     # A blob type, appropriate for storing binary data of any length.
+    # Not indexed.
     class Blob < String
       def to_java
         JavaDatastore::Blob.new(self.to_java_bytes)

data/lib/appengine-apis/logger.rb

@@ -19,10 +19,23 @@
 # Replacement for the standard logger.rb which uses the Google App Engine
 # logging API.
 
+
 require 'appengine-apis/apiproxy'
 require 'logger'
 
 module AppEngine
+  
+  # Replacement for the standard logger.rb. Saves logs to the App Engine
+  # Dashboard (or to the java logging api when running locally).
+  #
+  #   logger = AppEngine::Logger.new
+  #   logger.warn "foobar"
+  #
+  # or (for compatibility with code already using logger.rb)
+  #
+  #  Logger = AppEngine::Logger
+  #  logger = Logger.new(stream)  # stream is ignored
+  #  logger.info "Hello, dashboard"
   class Logger < ::Logger
     SEVERITIES = {
       DEBUG => ApiProxy::LogRecord::Level::debug,

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

@@ -20,7 +20,10 @@
 
 require 'merb-core/logger'
 
-module Merb
+module Merb  # :nodoc:
+  
+  # Modifies the Merb Logger class to save logs using the Logging API
+  # instead of writing directly to a stream.
   class Logger
     def <<(string = nil)
       AppEngine::ApiProxy.log(

data/lib/appengine-apis/testing.rb

@@ -18,9 +18,18 @@
 #
 # Helpers for installing stub apis in unit tests.
 
+
 require 'appengine-apis/apiproxy'
 
 module AppEngine
+  
+  # Local testing support for Google App Engine
+  #
+  # If you run your code on Google's servers or under dev_appserver,
+  # the api's are already configured.
+  #
+  # 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
@@ -28,7 +37,7 @@ module AppEngine
     class TestEnv  # :nodoc:
       include AppEngine::ApiProxy::Environment
       
-      attr_writer :appid, :version, :email, :admin, :logged_in
+      attr_writer :appid, :version, :email, :admin
       attr_writer :auth_domain, :request_namespace, :default_namespace
       
       def initialize
@@ -50,11 +59,11 @@ module AppEngine
       end
       
       def isLoggedIn
-        @logged_in
+        !(@email.nil? || @auth_domain.nil?)
       end
       
       def isAdmin
-        @admin
+        !!@admin
       end
       
       def getAuthDomain
@@ -75,26 +84,43 @@ module AppEngine
     end
     
     class << self
+      
+      # Install a test environment for the current thread.
+      #
+      # You must call this before making any api calls.
+      #
+      # Note that Google's production and local environments are
+      # single threaded. You may run into problems if you use multiple
+      # threads.
       def install_test_env
         env = TestEnv.new
         ApiProxy::setEnvironmentForCurrentThread(env)
         env
       end
       
-      def factory
+      def factory  # :nodoc:
         @factory ||= ApiProxyLocalFactory.new
       end
       
+      # The application directory, or '.' if not set.
+      # Composite index definitions are written to "#{app_dir}/WEB-INF/".
       def app_dir
         file = factory.getApplicationDirectory
         file && file.path
       end
-      
+
+      # Sets the application directory. Should be called before
+      # creating stubs.
+      #
+      # Composite index definitions are written to "#{app_dir}/WEB-INF/".      
       def app_dir=(dir)
         factory.setApplicationDirectory(java.io.File.new(dir))
       end
       
-      # Force all datastore operations to use an in-memory datastore.
+      # Install stub apis and force all datastore operations to use
+      # an in-memory datastore.
+      #
+      # You may call this multiple times to reset to a new in-memory datastore.
       def install_test_datastore
         self.app_dir = '.' if app_dir.nil?
         delegate = factory.create
@@ -110,6 +136,12 @@ module AppEngine
         delegate
       end
       
+      # Install stub apis. The datastore will be written to the disk
+      # inside #app_dir.
+      #
+      # You could potentially use this to run under a ruby web server
+      # instead of dev_appserver. In that case you will need to install
+      # and configure a test environment for each request.
       def install_api_stubs
         self.app_dir = '.' if app_dir.nil?
         delegate = factory.create

data/lib/appengine-apis/urlfetch.rb

@@ -0,0 +1,226 @@
+#!/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 'net/https'
+
+
+module AppEngine
+  # The URLFetch Service provides a way for user code to execute HTTP requests
+  # to external URLs.
+  #
+  # Chunked and hanging requests are not supported, and all content will be
+  # returned in a single block.
+  module URLFetch
+    import com.google.appengine.api.urlfetch.FetchOptions
+    import com.google.appengine.api.urlfetch.HTTPHeader
+    import com.google.appengine.api.urlfetch.HTTPMethod
+    import com.google.appengine.api.urlfetch.HTTPRequest
+    import com.google.appengine.api.urlfetch.ResponseTooLargeException
+    import com.google.appengine.api.urlfetch.URLFetchServiceFactory
+    
+    # Raised if the remote service could not be contacted
+    class DownloadError < StandardError; end
+
+    # Raised if the url cannot be parsed.
+    class InvalidURLError < StandardError; end
+    
+    # Raised if the response is too large.
+    class ResponseTooLargeError < StandardError; end
+    
+    module_function
+    
+    #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)
+    # [:headers]
+    #    HTTP headers to send with the request. May be a Hash or
+    #    Net::HTTPHeaders.
+    # [:allow_truncated]
+    #    if true, truncate large responses and return them
+    #    without error. otherwise, ResponseTooLargeError will be thrown when a
+    #    response is truncated.
+    # [:follow_redirects]
+    #     if true (the default), redirects are transparently followed and the
+    #     response (if less than 5 redirects) contains the final destination's
+    #     payload and the response status is 200.  You lose, however, the
+    #     redirect chaininformation.  If false, you see the HTTP response
+    #     yourself, including the 'Location' header, and redirects are not
+    #     followed.
+    #
+    # Returns a Net::HTTPResponse.
+    #
+    # Throws:
+    # - InvalidURLError if the provided url is malformed.
+    # - DownloadError if the remote service could not be contacted or the URL
+    #   could not be fetched.
+    # - ResponseTooLargeError if response truncation has been disabled  and the
+    #   response is too large. Some responses are too large to even retrieve
+    #   from the remote server, and in these cases the exception is thrown even
+    #   if response truncation is enabled.
+    #
+    def fetch(url, options={})
+      request = build_urlfetch_request(url, options)
+      begin
+        java_response = urlfetch_service.fetch(request)
+        return convert_urlfetch_body(java_response)
+      rescue java.lang.IllegalArgumentException => ex
+        raise ArgumentError, ex.message
+      rescue java.net.MalformedURLException => ex
+        raise InvalidURLError, ex.message
+      rescue java.io.IOException => ex
+        raise DownloadError, ex.message
+      rescue ResponseTooLargeException => ex
+        raise ResponseTooLargeError, ex.message
+      end
+    end
+    
+    def build_urlfetch_request(url, options)  # :nodoc:
+      method = options.delete(:method) || 'GET'
+      payload = options.delete(:payload)
+      headers = options.delete(:headers) || {}
+      truncate = options.delete(:allow_truncated)
+      follow_redirects = options.delete(:follow_redirects) || true
+      
+      unless options.empty?
+        raise ArgumentError, "Unsupported options #{options.inspect}."
+      end
+      
+      begin
+        method = HTTPMethod.value_of(method.to_s.upcase)
+      rescue java.lang.IllegalArgumentException
+        raise ArgumentError, "Invalid method #{method.inspect}."
+      end
+      
+      if truncate
+        options = FetchOptions::Builder.allow_truncate
+      else
+        options = FetchOptions::Builder.disallow_truncate
+      end
+      if follow_redirects
+        options.follow_redirects
+      else
+        options.do_not_follow_redirects
+      end
+      
+      url = java.net.URL.new(url) unless url.java_kind_of? java.net.URL
+      request = HTTPRequest.new(url, method, options)
+      
+      iterator = if headers.respond_to?(:canonical_each)
+        :canonical_each
+      else
+        :each
+      end
+      
+      headers.send(iterator) do |name, value|
+        request.set_header(HTTPHeader.new(name, value))
+      end
+      
+      if payload
+        request.set_payload(payload.as_java_bytes)
+      end
+      
+      return request
+    end
+    
+    def convert_urlfetch_body(java_response)  # :nodoc:
+      status = java_response.response_code.to_s
+      klass = Net::HTTPResponse.send(:response_class, status)
+      mesg = klass.name
+      mesg = mesg[4, mesg.size]
+      response = klass.new(nil, status, mesg)
+      java_response.headers.each do |header|
+        response.add_field(header.name, header.value)
+      end
+      body = if java_response.content
+        String.from_java_bytes(java_response.content)
+      else
+        nil
+      end
+      response.urlfetch_body = body
+      return response
+    end
+    
+    def urlfetch_service  # :nodoc:
+      @service ||= URLFetchServiceFactory.getURLFetchService
+    end
+    
+    def urlfetch_service=(service)  # :nodoc:
+      @service = service
+    end
+
+    
+    # A subclass of Net::HTTP that makes requests using Google App Engine's
+    # URLFetch Service.
+    #
+    # To replace the standard implementation throughout your app you can do:
+    #   require 'appengine-apis/urlfetch'
+    #   Net::HTTP = AppEngine::URLFetch::HTTP
+    class HTTP < Net::HTTP
+      alias connect on_connect
+
+      def request(req, body=nil, &block)
+        begin
+          proto = use_ssl? ? 'https' : 'http'
+          url = "#{proto}://#{addr_port}#{req.path}"
+          options = {
+              :payload => body,
+              :follow_redirects => false,
+              :allow_truncated => true,
+              :method => req.method,
+              :headers => req
+              }
+          res = URLFetch.fetch(url, options)
+        end while res.kind_of?(Net::HTTPContinue)
+        res.reading_body(nil, req.response_body_permitted?) {
+          yield res if block_given?
+        }
+        return res
+      end
+    end
+  end
+end
+
+module Net  # :nodoc:
+  class HTTPResponse  # :nodoc:
+    alias stream_check_without_urlfetch stream_check
+  
+    def stream_check
+      return if @urlfetch_body
+      stream_check_without_urlfetch
+    end
+  
+    alias read_body_0_without_urlfetch read_body_0
+
+    def read_body_0(dest)
+      if @urlfetch_body
+        dest << @urlfetch_body
+        return
+      else
+        read_body_0_without_urlfetch(dest)
+      end
+    end
+  
+    def urlfetch_body=(body)
+      @body_exist = body && self.class.body_permitted?
+      @urlfetch_body = body || ''
+    end
+  end
+end

data/lib/appengine-apis/users.rb

@@ -0,0 +1,105 @@
+#!/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.
+#
+
+module AppEngine
+  # Users provides information useful for forcing a user to log in or out, and
+  # retrieving information about the user who is currently logged-in.
+  module Users
+    import com.google.appengine.api.users.User
+    import com.google.appengine.api.users.UserServiceFactory
+    
+    Service = UserServiceFactory.getUserService
+    
+    class << self
+      
+      # If the user is logged in, this method will return a User that contains
+      # information about them. Note that repeated calls may not necessarily
+      # return the same User object.
+      def current_user
+        Service.current_user
+      end
+      
+      # Computes the login URL for this request and specified destination URL.
+      # 
+      # Args:
+      # - dest_url: The desired final destination URL for the user
+      #             once login is complete. If +dest_url+ does not have a host
+      #             specified, we will use the host from the current request.
+      def create_login_url(url)
+        Service.create_login_url(url)
+      end
+      
+      # Computes the logout URL for this request and specified destination URL.
+      # 
+      # Args:
+      # - dest_url: String that is the desired final destination URL for the
+      #             user once logout is complete. If +dest_url+ does not have
+      #             a host specified, uses the host from the current request.
+      def create_logout_url(url)
+        Service.create_logout_url(url)
+      end
+      
+      # Returns true if there is a user logged in, false otherwise.
+      def logged_in?
+        Service.is_user_logged_in?
+      end
+      
+      # Returns true if the user making this request is an admin for this
+      # application, false otherwise.
+      # 
+      # This is a separate function, and not a member function of the User
+      # class, because admin status is not persisted in the datastore. It
+      # only exists for the user making this request right now.
+      def admin?
+        Service.is_user_admin?
+      end
+    end
+    
+    # User represents a specific user, represented by the combination of an
+    # email address and a specific Google Apps domain (which we call an
+    # auth_domain). For normal Google login, authDomain will be set to
+    # "gmail.com".
+    class User
+      alias == equals?
+      alias to_s toString
+      
+      if nil  # rdoc only
+        # Creates a new User.
+        #
+        # Args:
+        # - email: a non-nil email address.
+        # - auth_domain: a non-nil domain name into which this user has
+        #   authenticated, or "gmail.com" for normal Google authentication.
+        def initialize(email, auth_domain)
+        end
+        
+        # Return this user's nickname. The nickname will be a unique, human
+        # readable identifier for this user with respect to this application.
+        # It will be an email address for some users, but not all.
+        def nickname
+        end
+        
+        def auth_domain
+        end
+        
+        def email
+        end
+      end
+    end
+  end
+end

data/spec/spec.opts

@@ -1 +1 @@
---colour
+--colour --backtrace

data/spec/urlfetch_spec.rb

@@ -0,0 +1,152 @@
+#!/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/urlfetch'
+require 'uri'
+
+module AppEngine::URLFetch
+  class FakeResponse
+    def initialize(status, body, headers)
+      @headers = java.util.ArrayList.new
+      headers.each do |k, v|
+        @headers << HTTPHeader.new(k, v)
+      end
+      @content = body.to_java_bytes if body
+      @status = status
+    end
+    
+    def getResponseCode
+      @status
+    end
+    alias get_response_code getResponseCode
+    alias response_code getResponseCode
+    
+    def getContent
+      @content
+    end
+    alias get_content getContent
+    alias content getContent
+    
+    def getHeaders
+      @headers
+    end
+    alias get_headers getHeaders
+    alias headers getHeaders
+  end
+end
+
+describe AppEngine::URLFetch do
+  HTTPRequest = com.google.appengine.api.urlfetch.HTTPRequest
+  
+  before :each do
+    AppEngine::URLFetch.urlfetch_service = mock("URLFetchService")
+    @url = 'http://foo.example.com/'
+  end
+  
+  def fetch_and_return(status, body='body', headers={}, &block)
+    response = AppEngine::URLFetch::FakeResponse.new(status, body, headers)
+    if block
+      AppEngine::URLFetch.urlfetch_service.should_receive(:fetch) do |req|
+        yield req
+        response
+      end
+    else
+      matcher = AppEngine::URLFetch.urlfetch_service.should_receive(:fetch)
+      matcher.with(kind_of(HTTPRequest)).and_return(response)
+    end
+  end
+  
+  it "should fetch correct url" do
+    fetch_and_return(200) do |req|
+      req.url.to_string.should == @url
+    end
+    AppEngine::URLFetch.fetch(@url)
+  end
+  
+  it "should read ok status" do
+    fetch_and_return(200)
+    
+    AppEngine::URLFetch.fetch(@url).should be_a(Net::HTTPOK)
+  end
+
+  it "should read error status" do
+    fetch_and_return(500)
+    AppEngine::URLFetch.fetch(@url).should be_a(Net::HTTPInternalServerError)
+  end
+  
+  it "should read body" do
+    fetch_and_return(200, 'foo')
+    AppEngine::URLFetch.fetch(@url).body.should == 'foo'
+  end
+    
+  it "should read binary body" do
+    fetch_and_return(200, 'bar\0')
+    AppEngine::URLFetch.fetch(@url).body.should == 'bar\0'
+  end
+  
+  # TODO can't read fetch options, so there's no way to tell if they're set
+end
+
+describe AppEngine::URLFetch::HTTP do
+  HTTPRequest = com.google.appengine.api.urlfetch.HTTPRequest
+  
+  before :each do
+    AppEngine::URLFetch.urlfetch_service = mock("URLFetchService")
+    @url = 'http://foo.example.com/'
+  end
+  
+  def fetch_and_return(status, body='body', headers={}, &block)
+    response = AppEngine::URLFetch::FakeResponse.new(status, body, headers)
+    if block
+      AppEngine::URLFetch.urlfetch_service.should_receive(:fetch) do |req|
+        yield req
+        response
+      end
+    else
+      matcher = AppEngine::URLFetch.urlfetch_service.should_receive(:fetch)
+      matcher.with(kind_of(HTTPRequest)).and_return(response)
+    end
+  end
+  
+  it "should  fetch correct url" do
+    fetch_and_return(200) do |req|
+      req.url.to_string.should == @url
+    end
+    AppEngine::URLFetch::HTTP.get URI.parse(@url)
+  end
+  
+  
+  it "should read body" do
+    fetch_and_return(200, 'foo')
+    AppEngine::URLFetch::HTTP.get(URI.parse(@url)).should == 'foo'
+  end
+  
+  it "should support https" do
+    @url = 'https://foo.example.com/'
+    fetch_and_return(200, 'secure') do |req|
+      req.url.to_string.should == @url
+    end
+    
+    uri = URI.parse(@url)
+    http = AppEngine::URLFetch::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true
+    http.get(uri.path).body.should == 'secure'
+  end
+end

data/spec/users_spec.rb

@@ -0,0 +1,58 @@
+# 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/users'
+
+describe AppEngine::Users do
+  before :all do
+    AppEngine::Testing::install_api_stubs
+  end
+  
+  before :each do
+    @env = AppEngine::Testing::install_test_env
+    @env.email = 'foo@example.com'
+  end
+  
+  it "should have default auth_domain" do
+    user = AppEngine::Users.current_user
+    user.email.should == 'foo@example.com'
+    user.auth_domain.should == 'gmail.com'
+  end
+  
+  it 'should read auth_domain' do
+    @env.auth_domain = 'example.com'
+    AppEngine::Users.current_user.auth_domain.should == 'example.com'
+  end
+  
+  it 'should read admin' do
+    AppEngine::Users.admin?.should == false
+    @env.admin = true
+    AppEngine::Users.admin?.should == true
+  end
+
+  it 'should set logged_in?' do
+    AppEngine::Users.logged_in?.should == true
+    @env.email = nil
+    AppEngine::Users.logged_in?.should == false
+  end
+  
+  it 'should create urls' do
+    login = AppEngine::Users.create_login_url('/foobar')
+    logout = AppEngine::Users.create_logout_url('/foobaz')
+    login.should =~ /foobar/
+    logout.should =~ /foobaz/
+  end
+end

metadata

@@ -9,7 +9,7 @@ email:
 - ribrdb@gmail.com
 cert_chain: []
 
-summary: APIs and utilities for using JRuby on Google App Engine.
+summary: APIs and utilities for using JRuby on Google App Engine
 post_install_message: PostInstall.txt
 extra_rdoc_files: 
 - History.txt
@@ -26,7 +26,11 @@ autorequire:
 rubyforge_project: appengine-jruby
 executables: []
 
-description: APIs and utilities for using JRuby on Google App Engine.
+description: 'APIs and utilities for using JRuby on Google App Engine.  See these
+  classes for an overview of each API: - AppEngine::Logger - AppEngine::Testing -
+  AppEngine::Users - AppEngine::URLFetch - AppEngine::Datastore  Unless you''re implementing
+  your own ORM, you probably want to use the DataMapper API instead of the lower level
+  AppEngine::Datastore API.'
 specification_version: 2
 default_executable: 
 files: 
@@ -42,6 +46,8 @@ files:
 - lib/appengine-apis/logger.rb
 - lib/appengine-apis/merb-logger.rb
 - lib/appengine-apis/testing.rb
+- lib/appengine-apis/urlfetch.rb
+- lib/appengine-apis/users.rb
 - script/console
 - script/destroy
 - script/generate
@@ -50,6 +56,8 @@ files:
 - spec/logger_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
+- spec/urlfetch_spec.rb
+- spec/users_spec.rb
 - tasks/rspec.rake
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
@@ -64,12 +72,12 @@ requirements: []
 
 authors: 
 - Ryan Brown
-date: 2009-04-10 07:00:00 +00:00
+date: 2009-04-15 07:00:00 +00:00
 platform: ruby
 test_files: []
 
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 require_paths: 
 - lib
 dependencies: