relax 0.0.7 → 0.1.0

data/spec/query_spec.rb

@@ -1,60 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-require 'relax/query'
-
-describe 'a query' do
-  before(:each) do
-    @uri = URI::parse('http://example.com/?action=search&query=keyword')
-    @query = Relax::Query.new
-  end
-
-  it 'should convert to a query string' do
-    @query[:action] = 'Search'
-    @query[:query] = 'strings'
-    @query.to_s.should eql('action=Search&query=strings')
-  end
-
-  it 'should convert its values to strings' do
-    date = Date.today
-    @query[:date] = date
-    @query.to_s.should eql("date=#{date.to_s}")
-  end
-
-  it 'should escape its values using "+" instead of "%20"' do
-    Relax::Query.send(:escape_value, 'two words').should == 'two+words'
-  end
-  
-  it 'should sort its parameters' do
-    @query[:charlie] = 3
-    @query[:alpha] = 1
-    @query[:bravo] = 2
-    @query.to_s.should eql('alpha=1&bravo=2&charlie=3')
-  end
-
-  it 'should encode its parameter values' do
-    @query[:spaces] = 'two words'
-    @query[:url] = 'http://example.com/'
-    @query.to_s.should eql('spaces=two+words&url=http%3A%2F%2Fexample.com%2F')
-  end
-
-  it 'should be able to parse query strings' do
-    parsed_query = Relax::Query.parse(@uri)
-    parsed_query[:action].should eql('search')
-    parsed_query[:query].should eql('keyword')
-  end
-  
-  it 'should parse key value pairs into only two parts' do
-    parsed_query = Relax::Query.parse(URI.parse("http://example.com/?action=test=&foo=bar"))
-    parsed_query[:action].should eql('test=')
-  end
-  
-  it 'should unescape query string key-value pair keys' do
-    parsed_query = Relax::Query.parse(URI.parse("http://example.com/?action%20helper=test"))
-    parsed_query[:"action helper"].should eql('test')
-  end
-  
-  it 'should unescape query string key-value pair values' do
-    parsed_query = Relax::Query.parse(URI.parse("http://example.com/?action=test%20action"))
-    parsed_query[:action].should eql('test action')
-  end
-end

data/spec/request_spec.rb

@@ -1,114 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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/symbolic_hash_spec.rb

@@ -1,67 +0,0 @@
-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