dbalatero-relax 0.0.7.1

data/spec/request_spec.rb

@@ -0,0 +1,114 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'relax/request'
+
+class Amount < Relax::Request
+  parameter :amount
+  parameter :currency
+end
+
+class TestRequest < Relax::Request
+  parameter :action, :required => true
+  parameter :token_id
+  parameter :user_id
+  parameter :amount, :type => Amount
+end
+
+class ChildRequest < TestRequest
+  parameter :child_id
+end
+
+describe 'an option initialized request', :shared => true do
+  it 'should have its values set by the options hash' do
+    request = TestRequest.new(:action => 'FetchAll', :token_id => 123)
+    request.action.should eql('FetchAll')
+    request.token_id.should eql(123)
+    request.user_id.should be_nil
+  end
+end
+
+describe 'a request that converts to a query', :shared => true do
+  before(:each) do
+    @query = TestRequest.new(:action => 'Search', :token_id => 123).to_query
+  end
+
+  it 'should include its parameters in the query' do
+    @query[:action].should eql('Search')
+    @query[:token_id].should eql('123')
+    @query[:user_id].should be_nil
+    @query[:amount].should be_nil
+  end
+
+  it 'should only include parameters in the query if they are set' do
+    @query.key?(:action).should be_true
+    @query.key?(:token_id).should be_true
+    @query.key?(:user_id).should be_false
+    @query.key?(:amount).should be_false
+  end
+end
+
+describe 'a normal request' do
+  it_should_behave_like 'a request that converts to a query'
+  it_should_behave_like 'an option initialized request'
+
+  it 'should raise an exception if a required parameter is missing' do
+    lambda {
+      TestRequest.new(:token_id => 123).valid?
+    }.should raise_error(Relax::MissingParameter)
+  end
+end
+
+describe 'a template request' do
+  it_should_behave_like 'a request that converts to a query'
+  it_should_behave_like 'an option initialized request'
+
+  before(:each) do
+    # this syntax may need to go away unless we can find a way to make it work 
+    TestRequest[:api_key] = '123456'
+    TestRequest[:secret] = 'shhh!'
+  end
+
+  it 'should always have the template values in its query' do
+    request = TestRequest.new
+    request.api_key.should eql('123456')
+    request.secret.should eql('shhh!')
+  end
+
+  it 'should allow its template variables to be overridden' do
+    request = TestRequest.new(:secret => 'abracadabra')
+    request.api_key.should eql('123456')
+    request.secret.should eql('abracadabra')
+  end
+
+  it 'should pass its template on to its children' do
+    request = ChildRequest.new
+    request.api_key.should eql('123456')
+    request.secret.should eql('shhh!')
+  end
+
+  it 'should allow template parameters on its children that are additive' do
+    ChildRequest[:query] = '1a2b3c'
+    child = ChildRequest.new
+    child.api_key.should eql('123456')
+    child.secret.should eql('shhh!')
+    child.query.should eql('1a2b3c')
+
+    parent = TestRequest.new
+    parent.api_key.should eql('123456')
+    parent.secret.should eql('shhh!')
+    parent.respond_to?(:query).should be_false
+  end
+end
+
+describe 'a request with a custom type' do
+  before(:each) do
+    request = TestRequest.new(:action => 'Pay', :token_id => 123)
+    request.amount = Amount.new(:amount => 3.50, :currency => 'USD')
+    @query = request.to_query
+  end
+
+  it 'should add the type parameters to the query' do
+    @query.key?(:"amount.amount").should be_true
+    @query.key?(:"amount.currency").should be_true
+  end
+end

data/spec/response_spec.rb

@@ -0,0 +1,98 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+
+class BaseResponse < Relax::Response
+  parameter :status, :required => true
+  parameter :request_id, :element => :requestid, :type => :integer
+end
+
+class TestResponse < BaseResponse
+  class Token < Relax::Response
+    parameter :token_id, :element => :tokenid
+    parameter :status
+  end
+
+  class Error < Relax::Response
+    parser :hpricot
+    parameter :code, :type => :integer
+    parameter :message
+  end
+
+  parameter :valid_request, :element => :requestid, :attribute => :valid
+  parameter :tokens, :collection => Token
+  parameter :error, :type => Error
+end
+
+
+describe 'a response' do
+  before(:each) do
+    @response = Relax::Response.new(XML)
+  end
+
+  it 'should allow access to the root' do
+    root = @response.root
+    root.should be_an_instance_of(Hpricot::Elem)
+    root.name.should eql('RESTResponse')
+  end
+
+  it 'should be checkable by the name of its root' do
+    @response.is?(:RESTResponse).should be_true
+  end
+
+  it 'should allow access to an element by its name' do
+    @response.element(:RequestId).should be_an_instance_of(Hpricot::Elem)
+  end
+
+  it 'should allow access to an element\'s elements by its name' do
+    tokens = @response.elements(:Tokens)
+    tokens.should be_an_instance_of(Hpricot::Elements)
+    tokens.should_not be_empty
+  end
+
+  it 'should allow access to an element\'s value by its name' do
+    token = Relax::Response.new(@response.elements(:Tokens).first)
+    token.element(:TokenId).inner_text.should eql('JPMQARDVJK')
+    token.element(:Status).inner_text.should eql('Active')
+  end
+
+  it 'should have a means of checking for the existence of a node' do
+    @response.has?(:Status).should_not be_nil
+    @response.has?(:Errors).should be_nil
+  end
+
+  it 'should be able to define children of Response without modifying parent' do
+    Relax::Response.new(XML).respond_to?(:status).should be_false
+    TestResponse.new(XML).respond_to?(:status).should be_true
+  end
+
+  it 'should automatically pull parameters from the XML' do
+    response = TestResponse.new(XML)
+    response.valid_request.should eql('true')
+    response.tokens.length.should eql(2)
+    response.tokens.first.status.should eql('Active')
+    response.error.code.should eql(1)
+    response.error.message.should eql('Failed')
+  end
+
+  it "should automatically pull its parent's parameters from the XML" do
+    response = TestResponse.new(XML)
+    response.status.should eql('Success')
+    response.request_id.should eql(44287)
+  end
+
+  it 'should be relationally equivalent to its children' do
+    (Relax::Response === TestResponse).should be_true
+  end
+
+  it 'should raise MissingParameter if required parameters are missing' do
+    proc { TestResponse.new('') }.should raise_error(Relax::MissingParameter)
+  end
+  
+  it 'should use the default parser when undefined' do
+    TestResponse::Token.new('').parser_name.should ==:default
+  end
+  
+  it 'should use the defined parser when given' do
+    TestResponse::Error.new('').parser_name.should ==:hpricot
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'spec'
+
+require File.dirname(__FILE__) + '/../lib/relax'
+
+unless defined?(XML)
+  XML = <<-EOF
+    <?xml version="1.0"?>
+    <RESTResponse xmlns:ns1="http://namespace.url">
+      <Tokens>
+        <TokenId>JPMQARDVJK</TokenId>
+        <Status>Active</Status>
+      </Tokens>
+      <Tokens>
+        <TokenId>RDVJKJPMQA</TokenId>
+        <Status>Inactive</Status>
+      </Tokens>
+      <Status>Success</Status>
+      <RequestId valid="true">44287</RequestId>
+      <ns1:Namespace>Passed</ns1:Namespace>
+      <Error>
+        <Code>1</Code>
+        <Message>Failed</Message>
+      </Error>
+    </RESTResponse>
+  EOF
+end

data/spec/symbolic_hash_spec.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'relax/symbolic_hash'
+
+describe 'a symbolic hash' do
+  before(:each) do
+    @url = 'http://example.com/'
+    @query = Relax::SymbolicHash.new
+  end
+
+  it 'should be accessible via string or symbol keys' do
+    @query[:amount] = 10
+    @query[:amount].should == 10
+    @query['amount'].should == 10
+  end
+
+  it 'should convert keys to symbols' do
+    @query['symbol'] = 'aleph'
+    @query[:symbol].should == 'aleph'
+  end
+
+  it 'should convert keys to symbols' do
+    @query['symbol'] = 'aleph'
+    @query[:symbol].should == 'aleph'
+  end
+
+  it 'should test for keys by symbol' do
+    @query[:symbol] = 'aleph'
+    @query.key?('symbol').should be_true
+  end
+
+  it 'should delete values with a symbolic key' do
+    @query[:symbol] = 'aleph'
+    @query.delete('symbol')
+    @query.key?(:symbol).should be_false
+  end
+
+  it 'should be mergeable' do
+    @query[:one] = 2
+    merged_query = @query.merge({ :one => 1, :two => 2 })
+    merged_query[:one].should == 1
+    merged_query[:two].should == 2
+  end
+
+  it 'should be able to duplicate itself' do
+    @query[:one] = 'uno'
+    @query[:two] = 'dos'
+    new_query = @query.dup
+    new_query[:one].should == 'uno'
+    new_query[:two].should == 'dos'
+
+    @query[:three] == 'tres'
+    new_query.key?(:three).should be_false
+  end
+
+  it 'should be able to get multiple values by symbol' do
+    @query[:one] = 1
+    @query[:two] = 2
+    @query.values_at(:one, :two).should == [1, 2]
+  end
+
+  it 'should be instantiable with a hash' do
+    query = Relax::SymbolicHash.new({ :one => 1, :two => 2 })
+    query[:one].should == 1
+    query[:two].should == 2
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: dbalatero-relax
+version: !ruby/object:Gem::Version 
+  version: 0.0.7.1
+platform: ruby
+authors: 
+- Tyler Hunt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-03 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: A simple library for creating REST consumers.
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/relax/parsers/base.rb
+- lib/relax/parsers/factory.rb
+- lib/relax/parsers/hpricot.rb
+- lib/relax/parsers/rexml.rb
+- lib/relax/parsers.rb
+- lib/relax/query.rb
+- lib/relax/request.rb
+- lib/relax/response.rb
+- lib/relax/service.rb
+- lib/relax/symbolic_hash.rb
+- lib/relax.rb
+- spec/parser_helper.rb
+- spec/parsers/factory_spec.rb
+- spec/parsers/hpricot_spec.rb
+- spec/parsers/rexml_spec.rb
+- spec/query_spec.rb
+- spec/request_spec.rb
+- spec/response_spec.rb
+- spec/spec_helper.rb
+- spec/symbolic_hash_spec.rb
+has_rdoc: false
+homepage: http://github.com/tylerhunt/relax/tree/master
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: AWS FPS Ruby API
+test_files: []
+