dynamodb 0.0.2

data/.gitignore

@@ -0,0 +1,2 @@
+.rvmrc
+Gemfile.lock

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/README.md

@@ -0,0 +1,48 @@
+DynamoDB
+========
+
+Communicate with [Amazon DynamoDB](http://aws.amazon.com/dynamodb/) from Ruby.
+
+This is a lightweight alternative to the official Amazon AWS gem.
+
+The goal of this library is to be a high performance driver, not an ORM.
+
+Usage
+-----
+
+The API maps the DynamoDB API closely. Once the connection object is ready, all
+requests are done through `#post`. The first argument is the name of the
+operation, the second is a hash that will be converted to JSON and used as the
+request body.
+
+    require 'dynamodb'
+
+    conn = DynamoDB::Connection.new 'ACCESS_KEY', 'SECRET_KEY'
+
+    conn.post :ListTables
+    => {"TableNames" => ["someTable", "anotherTable"]}
+
+    conn.post :GetItem, {:TableName => "someTable", :Key => {:S => "someKey"}}
+    => { ... }
+
+TODO
+----
+
+* Implement Signature Version 4
+
+Credits
+-------
+
+This project started as a fork of [Jedlik](https://github.com/hashmal/jedlik) 
+by [Jérémy Pinat](https://github.com/hashmal) but has significantly diverged.
+
+License
+-------
+
+Copyright (c) 2011-2012 GroupMe, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,4 @@
+require 'bundler/gem_tasks'
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/dynamodb.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |s|
+  s.name         = 'dynamodb'
+  s.version      = '0.0.2'
+  s.summary      = "Communicate with Amazon DynamoDB."
+  s.description  = "Communicate with Amazon DynamoDB. Raw access to the full API without having to handle temporary credentials or HTTP requests by yourself."
+  s.authors      = ["Brandon Keene", "Dave Yeu"]
+  s.email        = ["bkeene@gmail.com", "dave@groupme.com"]
+  s.require_path = 'lib'
+  s.files        = `git ls-files`.split("\n")
+  s.test_files   = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables  = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.homepage     = 'http://github.com/groupme/dynamodb'
+
+  s.add_runtime_dependency 'typhoeus', '0.4.2'
+  s.add_runtime_dependency 'multi_json', '1.3.7'
+
+  s.add_development_dependency 'rspec', '2.8.0'
+  s.add_development_dependency 'webmock', '1.8.11'
+end
+

data/lib/dynamodb.rb

@@ -0,0 +1,89 @@
+require 'typhoeus'
+require 'time'
+require 'base64'
+require 'openssl'
+require 'cgi'
+require 'multi_json'
+
+module DynamoDB
+  class BaseError < RuntimeError
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+      super("#{response.code}: #{response.body}")
+    end
+  end
+
+  class ClientError < BaseError; end
+  class ServerError < BaseError; end
+  class TimeoutError < BaseError; end
+  class AuthenticationError < BaseError; end
+
+  require 'dynamodb/typhoeus/request'
+  require 'dynamodb/credentials'
+  require 'dynamodb/security_token_service'
+  require 'dynamodb/connection'
+  require 'dynamodb/response'
+
+  class << self
+    def serialize(object)
+      if object.kind_of?(Hash)
+        serialized = {}
+        object.each do |k, v|
+          next if blank?(v)
+          serialized[k.to_s] = encode_type(v)
+        end
+        serialized
+      else
+        encode_type(object)
+      end
+    end
+
+    def deserialize(object)
+      if object.values.first.kind_of?(Hash)
+        deserialized = {}
+        object.each do |k, value_hash|
+          deserialized[k] = decode_type(value_hash)
+        end
+        deserialized
+      else
+        decode_type(object)
+      end
+    end
+
+    private
+
+    def blank?(object)
+      if object.respond_to?(:empty?)
+        object.empty?
+      else
+        object.nil?
+      end
+    end
+
+    def encode_type(value)
+      case value
+      when Numeric
+        {"N" => value.to_s}
+      when TrueClass, FalseClass
+        {"N" => (value ? 1 : 0).to_s}
+      when Time
+        {"N" => value.to_f.to_s}
+      else
+        {"S" => value.to_s}
+      end
+    end
+
+    def decode_type(value_hash)
+      k = value_hash.keys.first
+      v = value_hash.values.first
+      case k
+      when "N" then v.include?('.') ? v.to_f : v.to_i
+      when "S" then v.to_s
+      else
+        raise "Type not recoginized: #{k}"
+      end
+    end
+  end
+end

data/lib/dynamodb/connection.rb

@@ -0,0 +1,97 @@
+module DynamoDB
+  # Establishes a connection to Amazon DynamoDB using credentials.
+  class Connection
+    DEFAULTS = {
+      :endpoint => 'dynamodb.us-east-1.amazonaws.com',
+      :timeout  => 5000 # ms
+    }
+
+    # Acceptable `opts` keys are:
+    #
+    #     :endpoint # DynamoDB endpoint to use.
+    #               # Default: 'dynamodb.us-east-1.amazonaws.com'
+    #
+    def initialize(opts = {})
+      opts = DEFAULTS.merge opts
+
+      if opts[:token_service]
+        @sts = opts[:token_service]
+      elsif opts[:access_key_id] && opts[:secret_access_key]
+        @sts = SecurityTokenService.new(opts[:access_key_id], opts[:secret_access_key])
+      else
+        raise ArgumentError.new("access_key_id and secret_access_key are required")
+      end
+
+      @endpoint = opts[:endpoint]
+      @timeout  = opts[:timeout]
+    end
+
+    # Create and send a request to DynamoDB.
+    # Returns a hash extracted from the response body.
+    #
+    # `operation` can be any DynamoDB operation. `data` is a hash that will be
+    # used as the request body (in JSON format). More info available at:
+    #
+    # http://docs.amazonwebservices.com/amazondynamodb/latest/developerguide
+    #
+    def post(operation, data={})
+      credentials = @sts.credentials
+
+      request = new_request(credentials, operation, MultiJson.dump(data))
+      request.sign(credentials)
+
+      hydra.queue(request)
+      hydra.run
+      response = request.response
+
+      if response.success?
+        case operation
+        when :Query, :Scan, :GetItem
+          DynamoDB::Response.new(response)
+        else
+          MultiJson.load(response.body)
+        end
+      else
+        raise_error(response)
+      end
+    end
+
+    private
+
+    def hydra
+      Typhoeus::Hydra.hydra
+    end
+
+    def new_request(credentials, operation, body)
+      Typhoeus::Request.new "https://#@endpoint/",
+        :method  => :post,
+        :body    => body,
+        :timeout => @timeout,
+        :connect_timeout => @timeout,
+        :headers => {
+          'host'                 => @endpoint,
+          'content-type'         => "application/x-amz-json-1.0",
+          'x-amz-date'           => (Time.now.utc.strftime "%a, %d %b %Y %H:%M:%S GMT"),
+          'x-amz-security-token' => credentials.session_token,
+          'x-amz-target'         => "DynamoDB_20111205.#{operation}",
+        }
+    end
+
+    def raise_error(response)
+      if response.timed_out?
+        raise TimeoutError.new(response)
+      else
+        case response.code
+        when 400..499
+          raise ClientError.new(response)
+        when 500..599
+          raise ServerError.new(response)
+        when 0
+          raise ServerError.new(response)
+        else
+          raise BaseError.new(response)
+        end
+      end
+    end
+  end
+end

data/lib/dynamodb/credentials.rb

@@ -0,0 +1,30 @@
+module DynamoDB
+  class Credentials
+    attr_reader :access_key_id, :secret_access_key, :session_token
+
+    def self.from_hash(hash)
+      new(hash["access_key_id"], hash["secret_access_key"], hash["session_token"])
+    end
+
+    def initialize(access_key_id, secret_access_key, session_token)
+      @access_key_id = access_key_id
+      @secret_access_key = secret_access_key
+      @session_token = session_token
+    end
+
+    def to_hash
+      {
+        "access_key_id" => access_key_id,
+        "secret_access_key" => secret_access_key,
+        "session_token" => session_token
+      }
+    end
+
+    def ==(other)
+      self.class == other.class &&
+      access_key_id == other.access_key_id &&
+      secret_access_key == other.secret_access_key &&
+      session_token == other.session_token
+    end
+  end
+end

data/lib/dynamodb/response.rb

@@ -0,0 +1,33 @@
+module DynamoDB
+  class Response
+    attr_reader :typhoeus_response
+
+    def initialize(typhoeus_response)
+      @typhoeus_response = typhoeus_response
+    end
+
+    def hash_key_element
+      DynamoDB.deserialize(json["LastEvaluatedKey"]["HashKeyElement"])
+    end
+
+    def range_key_element
+      DynamoDB.deserialize(json["LastEvaluatedKey"]["RangeKeyElement"])
+    end
+
+    def item
+      return unless json["Item"]
+      @item ||= DynamoDB.deserialize(json["Item"])
+    end
+
+    def items
+      return unless json["Items"]
+      @items ||= json["Items"].map { |i| DynamoDB.deserialize(i) }
+    end
+
+    private
+
+    def json
+      @json ||= MultiJson.load(typhoeus_response.body)
+    end
+  end
+end

data/lib/dynamodb/security_token_service.rb

@@ -0,0 +1,110 @@
+module DynamoDB
+  attr_writer :access_key_id
+  attr_writer :secret_acces_key
+  attr_writer :session_token
+
+  # SecurityTokenService automatically manages the creation and renewal of
+  # temporary AWS credentials.
+  #
+  # Usage:
+  #
+  #     credentials = SecurityTokenService.new "id", "secret key"
+  #     credentials.access_key_id     # => String
+  #     credentials.secret_access_key # => String
+  #     credentials.session_token     # => String
+  #
+  class SecurityTokenService
+    THIRTY_SIX_HOURS = 129600
+
+    # A SecurityTokenService is initialized for a single AWS user using his
+    # credentials.
+    def initialize(access_key_id, secret_access_key)
+      @_access_key_id = access_key_id
+      @_secret_access_key = secret_access_key
+      @credentials = nil
+    end
+
+    def credentials
+      obtain_credentials
+      @credentials
+    end
+
+    private
+
+    def signature(authorization_params)
+      sign(string_to_sign(authorization_params))
+    end
+
+    # The last line needs to be a query string of all parameters
+    # in the request in alphabetical order.
+    def string_to_sign(authorization_params)
+      [
+        "GET",
+        "sts.amazonaws.com",
+        "/",
+        "AWSAccessKeyId=#{@_access_key_id}" +
+          "&Action=GetSessionToken" +
+          "&DurationSeconds=#{THIRTY_SIX_HOURS}" +
+          "&SignatureMethod=HmacSHA256" +
+          "&SignatureVersion=2" +
+          "&Timestamp=#{CGI.escape(authorization_params[:Timestamp])}" +
+          "&Version=2011-06-15"
+      ].join("\n")
+    end
+
+    # Extract the contents of a given tag.
+    def get_tag(tag, string)
+      # Considering that the XML string received from STS is sane and always
+      # has the same simple structure, I think a simple regular expression
+      # can do the job (with the benefit of not adding a dependency on
+      # another library just for ONE method). I will switch to Nokogiri if
+      # needed.
+      string.match(/#{tag.to_s}>([^<]*)/)[1]
+    end
+
+    # Obtain temporary credentials, set to expire after 1 hour. If
+    # credentials were previously obtained, no request is made until they
+    # expire.
+    def obtain_credentials
+      return unless credentials_expired?
+
+      authorization_params = {
+        :Action           => 'GetSessionToken',
+        :Timestamp        => Time.now.utc.iso8601,
+        :Version          => '2011-06-15',
+        :DurationSeconds  => THIRTY_SIX_HOURS # 36 hour expiration
+      }
+
+      params = {
+        :AWSAccessKeyId   => @_access_key_id,
+        :SignatureMethod  => 'HmacSHA256',
+        :SignatureVersion => '2',
+        :Signature        => signature(authorization_params)
+      }.merge(authorization_params)
+
+      response = Typhoeus::Request.get("https://sts.amazonaws.com", :params => params)
+      if response.success?
+        body = response.body
+        @expiration = Time.parse(get_tag(:Expiration, body))
+        @credentials = Credentials.new(
+          get_tag(:AccessKeyId, body),
+          get_tag(:SecretAccessKey, body),
+          get_tag(:SessionToken, body))
+      else
+        raise AuthenticationError.new(response)
+      end
+    end
+
+    # Sign (HMAC-SHA256) a string using the secret key given at
+    # initialization.
+    def sign(string)
+      Base64.encode64(
+        OpenSSL::HMAC.digest('sha256', @_secret_access_key, string)
+      ).strip
+    end
+
+    def credentials_expired?
+      @expiration.nil? || @expiration <= Time.now.utc
+    end
+  end
+end

data/lib/dynamodb/typhoeus/request.rb

@@ -0,0 +1,27 @@
+module Typhoeus
+  class Request
+    def sign(credentials)
+      headers.merge!('x-amzn-authorization' => "AWS3 AWSAccessKeyId=#{credentials.access_key_id},Algorithm=HmacSHA256,Signature=#{digest(credentials.secret_access_key)}")
+    end
+
+    private
+
+    def digest(secret_key)
+      Base64.encode64(
+        OpenSSL::HMAC.digest('sha256', secret_key, Digest::SHA256.digest(string_to_sign))
+      ).strip
+    end
+
+    def string_to_sign
+      "POST\n/\n\nhost:#{parsed_uri.host}\n#{amz_to_sts}\n#{body}"
+    end
+
+    def amz_to_sts
+      get_amz_headers.sort.map {|key, val| [key, val].join(':') + "\n"}.join
+    end
+
+    def get_amz_headers
+      headers.select {|key, val| key =~ /\Ax-amz-/}
+    end
+  end
+end

data/spec/dynamodb/connection_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+require 'benchmark'
+
+describe DynamoDB::Connection do
+  let(:token_service) {
+    stub(:credentials =>
+      DynamoDB::Credentials.new(
+        "access_key_id",
+        "secret_access_key",
+        "session_token"
+      )
+    )
+  }
+
+  describe "#initialize" do
+    it "can be initialized with a token service" do
+      DynamoDB::Connection.new(:token_service => token_service)
+    end
+
+    it "can be initialized with an access key" do
+      DynamoDB::Connection.new(
+        :access_key_id => "id",
+        :secret_access_key => "secret"
+      )
+    end
+
+    context "no token service was provided" do
+      it "requires an access_key_id and secret_access_key" do
+        lambda {
+          DynamoDB::Connection.new
+        }.should raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "#post" do
+    let(:connection) { DynamoDB::Connection.new(:token_service => token_service) }
+
+    before do
+      Time.stub(:now => Time.at(1332635893)) # Sat Mar 24 20:38:13 -0400 2012
+
+      @url = "https://dynamodb.us-east-1.amazonaws.com/"
+      @headers = {
+        'Content-Type'          => 'application/x-amz-json-1.0',
+        'Host'                  => 'dynamodb.us-east-1.amazonaws.com',
+        'X-Amz-Date'            => 'Sun, 25 Mar 2012 00:38:13 GMT',
+        'X-Amz-Security-Token'  => 'session_token',
+        'X-Amzn-Authorization'  => 'AWS3 AWSAccessKeyId=access_key_id,Algorithm=HmacSHA256,Signature=2xa6v0WW+980q8Hgt+ym3/7C0D1DlkueGMugi1NWE+o='
+      }
+    end
+
+    it "signs and posts a request" do
+      @headers['X-Amz-Target'] = 'DynamoDB_20111205.ListTables'
+      stub_request(:post, @url).
+        with(
+          :body     => "{}",
+          :headers  => @headers
+        ).
+        to_return(
+          :status => 200,
+          :body => '{"TableNames":["example"]}',
+          :headers => {}
+        )
+
+      result = connection.post :ListTables
+      result.should == {"TableNames" => ["example"]}
+    end
+
+    it "type casts response when Query" do
+      stub_request(:post, @url).
+        to_return(
+          :status => 200,
+          :body => "{}",
+          :headers => {}
+        )
+
+      response = connection.post :Query, :TableName => "people", :HashKeyId => {:N => "1"}
+      response.should be_a_kind_of(DynamoDB::Response)
+    end
+
+    it "type casts response when GetItem" do
+      stub_request(:post, @url).
+        to_return(
+          :status => 200,
+          :body => "{}",
+          :headers => {}
+        )
+
+      response = connection.post :GetItem, :TableName => "people", :Key => {:HashKeyElement => {:N => "1"}, :RangeKeyElement => {:N => 2}}
+      response.should be_a_kind_of(DynamoDB::Response)
+    end
+
+    context "when a failure occurs" do
+      it "raises an error with the response attached" do
+        stub_request(:post, @url).to_return(:status => 500, :body => "Failed for some reason.")
+        error = nil
+        begin
+          connection.post :Query, :TableName => "people", :HashKeyId => {:N => "1"}
+        rescue => e
+          error = e
+        end
+        error.should be_an_instance_of(DynamoDB::ServerError)
+        error.response.code.should == 500
+        error.message.should == "500: Failed for some reason."
+      end
+    end
+
+    context "when the connection fails" do
+      it "raises a server error" do
+        stub_request(:post, @url).to_return(:status => 0, :body => "")
+        error = nil
+        begin
+          connection.post :Query, :TableName => "people", :HashKeyId => {:N => "1"}
+        rescue => e
+          error = e
+        end
+        error.should be_an_instance_of(DynamoDB::ServerError)
+        error.response.code.should == 0
+      end
+    end
+
+    context "when the connection times out" do
+      it "raises a DynamoDB::TimeoutError" do
+        stub_request(:post, @url).to_timeout
+        expect {
+          connection.post :Query, :TableName => "people", :HashKeyId => {:N => "1"}
+        }.to raise_error(DynamoDB::TimeoutError)
+      end
+    end
+  end
+end

data/spec/dynamodb/credentials_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe DynamoDB::Credentials do
+  describe "#==" do
+    it "is true for identical credentials" do
+      DynamoDB::Credentials.new("abc", "123", "token").should ==
+        DynamoDB::Credentials.new("abc", "123", "token")
+    end
+
+    it "is false otherwise" do
+      DynamoDB::Credentials.new("abc", "123", "token").should_not ==
+        DynamoDB::Credentials.new("abc", "123", "different token")
+    end
+  end
+
+  describe "#to_hash" do
+    it "converts to a hash and back" do
+      credentials = DynamoDB::Credentials.new("abc", "123", "token")
+      DynamoDB::Credentials.from_hash(credentials.to_hash).should == credentials
+    end
+  end
+end

data/spec/dynamodb/response_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe DynamoDB::Response do
+  before do
+    body = {
+      "LastEvaluatedKey" => {
+        "HashKeyElement" => {"N"=>"1"},
+        "RangeKeyElement"=>{"N"=>"1501"}
+      },
+      "Items"=>[
+        {
+          "name"=>{"S"=>"John Smith"},
+          "created_at"=>{"N"=>"1321564309.99428"},
+          "disabled"=>{"N"=>"0"},
+          "group_id"=>{"N"=>"1"},
+          "person_id"=>{"N" => "1500"}
+        },
+        {
+          "name"=>{"S"=>"Jane Smith"},
+          "created_at"=>{"N"=>"1321564309.99428"},
+          "disabled"=>{"N"=>"1"},
+          "group_id"=>{"N"=>"1"},
+          "person_id"=>{"N" => "1501"}
+        }
+      ],
+      "Count" => 1,
+      "ConsumedCapacityUnits" => 0.5
+    }
+    @typhoeus_response = mock("response", :body => MultiJson.dump(body))
+  end
+
+  describe "#hash_key_element" do
+    it "returns the typecast value of HashKeyElement" do
+      response = DynamoDB::Response.new(@typhoeus_response)
+      response.hash_key_element.should == 1
+    end
+  end
+
+  describe "#range_key_element" do
+    it "returns the typecast value of RangeKeyElement" do
+      response = DynamoDB::Response.new(@typhoeus_response)
+      response.range_key_element.should == 1501
+    end
+  end
+
+  context "Items" do
+    it "type casts response" do
+      response = DynamoDB::Response.new(@typhoeus_response)
+      response.items[0]["name"].should == "John Smith"
+      response.items[0]["created_at"].should == 1321564309.99428
+      response.items[0]["disabled"].should == 0
+      response.items[0]["group_id"].should == 1
+      response.items[0]["person_id"].should == 1500
+
+      response.items[1]["name"].should == "Jane Smith"
+      response.items[1]["created_at"].should == 1321564309.99428
+      response.items[1]["disabled"].should == 1
+      response.items[1]["group_id"].should == 1
+      response.items[1]["person_id"].should == 1501
+    end
+  end
+
+  context "Item" do
+    before do
+      body = {
+        "Item"=> {
+          "name"=>{"S"=>"John Smith"},
+          "created_at"=>{"N"=>"1321564309.99428"},
+          "disabled"=>{"N"=>"0"},
+          "group_id"=>{"N"=>"1"},
+          "person_id"=>{"N" => "1500"}
+        },
+        "ConsumedCapacityUnits" => 0.5
+      }
+      @typhoeus_response = mock("response", :body => MultiJson.dump(body))
+    end
+
+    it "type casts response" do
+      response = DynamoDB::Response.new(@typhoeus_response)
+      response.item["name"].should == "John Smith"
+      response.item["created_at"].should == 1321564309.99428
+      response.item["disabled"].should == 0
+      response.item["group_id"].should == 1
+      response.item["person_id"].should == 1500
+    end
+  end
+end

data/spec/dynamodb/security_token_service_spec.rb

@@ -0,0 +1,97 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module DynamoDB
+  describe SecurityTokenService do
+    let(:sts) { SecurityTokenService.new("access_key_id", "secret_access_key") }
+
+    context "success" do
+      before do
+        Time.stub(:now).and_return(Time.parse("2012-03-24T22:10:38Z"))
+        success_body = <<-XML
+          <GetSessionTokenResponse xmlns="https://sts.amazonaws.com/doc/2011-06-15/">
+          <GetSessionTokenResult>
+          <Credentials>
+          <SessionToken>session_token</SessionToken>
+          <SecretAccessKey>secret_access_key</SecretAccessKey>
+          <Expiration>2036-03-19T01:03:22.276Z</Expiration>
+          <AccessKeyId>access_key_id</AccessKeyId>
+          </Credentials>
+          </GetSessionTokenResult>
+          <ResponseMetadata>
+          <RequestId>f0fa5827-7156-11e1-8f1e-a92b58fdc66e</RequestId>
+          </ResponseMetadata>
+          </GetSessionTokenResponse>
+        XML
+
+        @request = stub_request(:get, "https://sts.amazonaws.com/").
+          with(:query => {
+            "AWSAccessKeyId"   => "access_key_id",
+            "Action"           => "GetSessionToken",
+            "Signature"        => "HyF65paDxprCe+zEHx7wxah+hiZ43PhvtmeehDtfuw8=",
+            "SignatureMethod"  => "HmacSHA256",
+            "SignatureVersion" => "2",
+            "Timestamp"        => "2012-03-24T22:10:38Z",
+            "Version"          => "2011-06-15",
+            "DurationSeconds"  => "129600"
+          }).to_return(:status => 200, :body => success_body)
+      end
+
+      it "obtains session_token, access_key_id, secret_access_key" do
+        sts = SecurityTokenService.new("access_key_id", "secret_access_key")
+        credentials = sts.credentials
+        credentials.access_key_id.should == "access_key_id"
+        credentials.secret_access_key.should == "secret_access_key"
+        credentials.session_token.should == "session_token"
+      end
+
+      it "does not query STS if the credentials are not expired" do
+        sts = SecurityTokenService.new("access_key_id", "secret_access_key")
+
+        sts.stub(:credentials_expired?).and_return(true)
+        sts.credentials
+        @request.should have_been_requested
+
+        WebMock.reset!
+
+        sts.stub(:credentials_expired?).and_return(false)
+        sts.credentials
+        @request.should_not have_been_requested
+      end
+    end
+
+    context "failure" do
+      before do
+        Time.stub(:now).and_return(Time.parse("2012-03-24T22:10:38Z"))
+        error_body = <<-XML
+          <ErrorResponse xmlns="https://sts.amazonaws.com/doc/2011-06-15/">
+            <Error>
+              <Type>Sender</Type>
+              <Code>InvalidClientTokenId</Code>
+              <Message>The security token included in the request is invalid</Message>
+            </Error>
+            <RequestId>a9f51cd0-7f5b-11e1-8022-bd0f2fc51c4b</RequestId>
+          </ErrorResponse>
+        XML
+
+        stub_request(:get, "https://sts.amazonaws.com/").
+          with(:query => {
+            "AWSAccessKeyId"   => "access_key_id",
+            "Action"           => "GetSessionToken",
+            "Signature"        => "HyF65paDxprCe+zEHx7wxah+hiZ43PhvtmeehDtfuw8=",
+            "SignatureMethod"  => "HmacSHA256",
+            "SignatureVersion" => "2",
+            "Timestamp"        => "2012-03-24T22:10:38Z",
+            "Version"          => "2011-06-15",
+            "DurationSeconds"  => "129600"
+          }).to_return(:status => 403, :body => error_body)
+      end
+
+      it "raises an AuthenticationError" do
+        s = SecurityTokenService.new("access_key_id", "secret_access_key")
+        proc {
+          s.credentials
+        }.should raise_error(DynamoDB::AuthenticationError)
+      end
+    end
+  end
+end

data/spec/dynamodb_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe DynamoDB do
+  describe "#serialize" do
+    it "serializes to dynamo type format" do
+      published_at = Time.now
+      hash = {
+        :id => 1,
+        :name => "Gone with the Wind",
+        :published_at => published_at,
+        :price => 11.99,
+        :active => true
+      }
+
+      DynamoDB.serialize(hash).should == {
+        "id" => {"N" => "1"},
+        "name" => {"S" => "Gone with the Wind"},
+        "published_at" => {"N" => published_at.to_f.to_s},
+        "price" => {"N" => "11.99"},
+        "active" => {"N" => "1"}
+      }
+    end
+
+    it "serializes a single value" do
+      DynamoDB.serialize(1).should == {"N" => "1"}
+      DynamoDB.serialize(1.5).should == {"N" => "1.5"}
+      DynamoDB.serialize("Hello World").should == {"S" => "Hello World"}
+    end
+
+    it "omits nil/blank values" do
+      DynamoDB.serialize("foo" => nil).should == {}
+      DynamoDB.serialize("foo" => "").should == {}
+    end
+  end
+
+  describe "#deserialize" do
+    it "deserializes single values" do
+      DynamoDB.deserialize({"N" => "123"}).should == 123
+      DynamoDB.deserialize({"S" => "Hello World"}).should == "Hello World"
+    end
+
+    it "deserializes from dynamo type format" do
+      published_at = Time.now
+      item = {
+        "id" => {"N" => "1"},
+        "name" => {"S" => "Gone with the Wind"},
+        "published_at" => {"N" => published_at.to_f.to_s},
+        "price" => {"N" => "11.99"},
+        "active" => {"N" => "1"}
+      }
+      deserialized = DynamoDB.deserialize(item)
+      deserialized["id"].should == 1
+      deserialized["name"].should == "Gone with the Wind"
+      deserialized["published_at"].to_s.should == published_at.to_f.to_s
+      deserialized["price"].should == 11.99
+      deserialized["active"].should == 1
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rspec'
+
+$:.unshift(File.join(File.dirname __FILE__), 'lib')
+require 'dynamodb'
+require 'webmock/rspec'
+
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: dynamodb
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Brandon Keene
+- Dave Yeu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: typhoeus
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.2
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.3.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.3.7
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.8.11
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.8.11
+description: Communicate with Amazon DynamoDB. Raw access to the full API without
+  having to handle temporary credentials or HTTP requests by yourself.
+email:
+- bkeene@gmail.com
+- dave@groupme.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- README.md
+- Rakefile
+- dynamodb.gemspec
+- lib/dynamodb.rb
+- lib/dynamodb/connection.rb
+- lib/dynamodb/credentials.rb
+- lib/dynamodb/response.rb
+- lib/dynamodb/security_token_service.rb
+- lib/dynamodb/typhoeus/request.rb
+- spec/dynamodb/connection_spec.rb
+- spec/dynamodb/credentials_spec.rb
+- spec/dynamodb/response_spec.rb
+- spec/dynamodb/security_token_service_spec.rb
+- spec/dynamodb_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/groupme/dynamodb
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Communicate with Amazon DynamoDB.
+test_files:
+- spec/dynamodb/connection_spec.rb
+- spec/dynamodb/credentials_spec.rb
+- spec/dynamodb/response_spec.rb
+- spec/dynamodb/security_token_service_spec.rb
+- spec/dynamodb_spec.rb
+- spec/spec_helper.rb