dwolla-ruby 1.1.0 → 2.0.0

data/lib/dwolla/response/parse_json.rb

@@ -1,27 +0,0 @@
-module Dwolla
-  module Response
-    class ParseJson < Faraday::Response::Middleware
-      def on_complete(env)
-        if respond_to? :parse
-          env[:body] = parse(env[:body]) unless [204,302,304,307].index env[:status]
-        end
-      end
-
-      def parse(body)
-        case body
-        when ''
-          nil
-        else
-          response_hash = ::MultiJson.load(body)
-
-          raise Dwolla::RequestException, response_hash["Message"] if response_hash["Success"] == false
-
-          response_hash["Response"] ||
-            response_hash["SendResult"] ||
-              response_hash["RequestResult"] ||
-                response_hash
-        end
-      end
-    end
-  end
-end

data/lib/dwolla/transaction.rb

@@ -1,56 +0,0 @@
-module Dwolla
-  class Transaction
-    include Dwolla::Connection
-    @test_mode = false
-    def self.test_mode
-      @test_mode
-    end
-    def self.test_mode=(m)
-      @test_mode = m
-    end
-
-    ENDPOINTS = { :send => 'transactions/send',
-                  :request => 'transactions/request' }
-    TEST_ENDPOINTS = { :send => 'testapi/send',
-                  :request => 'testapi/request' }
-
-    attr_accessor :origin, :destination, :destination_type, :type, :amount, :pin, :id, :source, :source_type, :description, :funds_source, :assume_costs
-
-    def initialize(attrs = {})
-      attrs.each do |key, value|
-        send("#{key}=".to_sym, value)
-      end
-    end
-
-    def execute
-      if self.class.test_mode
-        end_point = TEST_ENDPOINTS[type]
-      else
-        end_point = ENDPOINTS[type]
-      end
-      self.id = post(end_point, to_payload)
-    end
-
-    private
-
-      def auth_params
-        { :oauth_token => origin.oauth_token }
-      end
-
-      def to_payload
-        payload = {
-          :amount => amount,
-          :pin => pin
-        }
-        payload[:destinationId] = destination if destination
-        payload[:destinationType] = destination_type if destination_type
-        payload[:sourceId] = source if source
-        payload[:sourceType] = source_type if source_type
-        payload[:notes] = description if description
-        payload[:fundsSource] = funds_source if funds_source
-        payload[:assumeCosts] = assume_costs if assume_costs
-
-        payload
-      end
-  end
-end

data/lib/dwolla/user.rb

@@ -1,121 +0,0 @@
-module Dwolla
-  class User
-    include Dwolla::Connection
-
-    attr_accessor :id,
-                  :name,
-                  :latitude,
-                  :longitude,
-                  :city,
-                  :state,
-                  :type,
-                  :contact_type,
-                  :image,
-                  :oauth_token
-
-    def initialize(attrs={})
-      update_attributes(attrs)
-    end
-
-    def self.me(access_token)
-      User.new(:oauth_token => access_token)
-    end
-
-    def fetch
-      user_attributes = get('users')
-      update_attributes(user_attributes)
-      self
-    end
-
-    def update_attributes(attrs)
-      attrs.each do |key, value|
-        key_string = key.is_a?(String) ? key : key.to_s
-        send("#{key_string.downcase}=".to_sym, value)
-      end
-    end
-
-    def balance
-      get('balance')
-    end
-    
-    def funding_sources
-      sources = get('fundingsources')
-      sources.map{|s| FundingSource.from_json(s)}
-    end
-
-    def funding_source(funding_id)
-      sources = get('fundingsources?fundingid=' + funding_id)
-      sources.map{|s| FundingSource.from_json(s)}
-    end
-    
-    def add_funding_source(funding_source_hash)
-      params = auth_params.merge(funding_source_hash)
-      
-      returned_source_hash = post("fundingsources/", params)
-      FundingSource.from_json(returned_source_hash)
-    end
-
-    def deposit_funds(funding_id, pin, amount)
-      params = auth_params.merge(:pin => pin, :amount => amount, :funding_id => funding_id)
-      
-      returned_hash = post("fundingsources/#{funding_id}/deposit", params)
-      returned_hash
-    end
-
-    def withdraw_funds(funding_id, pin, amount)
-      params = auth_params.merge(:pin => pin, :amount => amount, :funding_id => funding_id)
-      
-      returned_hash = post("fundingsources/#{funding_id}/withdraw", params)
-      returned_hash
-    end
-
-
-    def contacts(options = {})
-      contacts_url = 'contacts'
-      contacts = get(contacts_url, options)
-
-      instances_from_contacts(contacts)
-    end
-
-    def send_money_to(destination, amount, pin, type='dwolla', description='', funds_source=nil, assume_costs=nil)
-      transaction = Transaction.new(:origin => self,
-                                    :destination => destination,
-                                    :destination_type => type,
-                                    :description => description,
-                                    :type => :send,
-                                    :amount => amount,
-                                    :pin => pin,
-                                    :funds_source => funds_source,
-                                    :assume_costs => assume_costs)
-
-      transaction.execute
-    end
-
-    def request_money_from(source, amount, pin, source_type='dwolla', description='')
-      transaction = Transaction.new(:origin => self,
-                                    :source => source,
-                                    :source_type => source_type,
-                                    :description => description,
-                                    :type => :request,
-                                    :amount => amount,
-                                    :pin => pin)
-      transaction.execute
-    end
-
-    private
-
-      def instances_from_contacts(contacts)
-        user_instances = []
-        contacts.each do |contact|
-          contact["Contact_Type"] = contact["Type"]
-          contact.delete("Type")
-          user_instances << User.new(contact)
-        end
-        user_instances
-      end
-
-      def auth_params
-        { :oauth_token => self.oauth_token }
-      end
-   end
-end

data/spec/dwolla/client_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-
-describe Dwolla::Client do
-  subject { Dwolla::Client.new('sample_client_id', 'sample_client_secret') }
-  let(:query_params) { "client_id=sample_client_id&client_secret=sample_client_secret" }
-
-  describe "getting user basic information" do
-    before do
-      stub_get('/users/812-111-1111', query_params).
-        to_return(:body => fixture("basic_information.json"))
-    end
-
-    it 'should request the correct resource' do
-      subject.user('812-111-1111')
-      a_get('/users/812-111-1111', query_params).should have_been_made
-    end
-
-    it 'should return extended information of a given user' do
-      user = subject.user('812-111-1111')
-      user.should be_a Dwolla::User
-      user.id.should == '812-111-1111'
-      user.name.should == 'Test User'
-      user.latitude.should == 41.584546
-      user.longitude.should == -93.634167
-    end
-  end
-  
-  describe "registering a user" do
-    it 'should register a user and return a user object' do
-      stub_post('/register/').
-        to_return(:body => fixture("register.json"))
-    
-      userhash = {"email" => "test@test.com",
-        "password" => "Asdfasdf43434",
-        "pin" => "4343",
-        "firstName" => "Test",
-        "lastName" => "User",
-        "address" => "204 W. Test St.",
-        "city" => "Lansing",
-        "state" => "MI",
-        "zip" => "48906",
-        "phone" => "5175557621",
-        "dateOfBirth" => "07-12-1983",
-        "type" => "Personal",
-        "acceptTerms" => "true"}
-      
-      user = subject.register_user(userhash)
-      user.name.should eq 'Test User'
-    end
-  end
-end

data/spec/dwolla/funding_source_spec.rb

@@ -1,59 +0,0 @@
-describe "Funding sources" do
-  let(:oauth_token) { 'valid_token' }
-  
-  describe "Getting a list of funding sources" do
-    before :each do
-      user = Dwolla::User.me(oauth_token)
-      stub_request(:get, "https://www.dwolla.com/oauth/rest/fundingsources?oauth_token=valid_token").
-               with(:headers => {'Accept'=>'application/json', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'Content-Type'=>'application/json', 'User-Agent'=>'Dwolla Ruby Wrapper'}).
-               to_return(:body => fixture("sources.json"))
-      @account = user.funding_sources.first
-    end
-    it "should be a FundingSource object" do
-      @account.should be_kind_of(Dwolla::FundingSource)
-    end
-    it "should get the correct id" do
-      @account.id.should == "mE06khgHy9K/Ii9n5fbUEg=="
-    end
-    it "should get the right name" do
-      @account.name.should == "Checking - My Bank"
-    end
-    it "should get the right type" do
-      @account.type.should == "Checking"
-    end
-    it "should get whether the account is verified" do
-      @account.should be_verified
-    end
-  end
-
-  describe "adding a funding source" do
-    it "should create a funding source" do
-      user = Dwolla::User.new(:oauth_token => '12345', :id => '1')
-    
-      stub_post('/fundingsources/').
-        to_return(:body => fixture("add_funding_source.json"))
-  
-      sourcehash = {
-        "account_number" => "4434343434",
-        "routing_number" => "343434343434",
-        "account_type" => "checking",
-        "name" => "My Checking Account - Checking"
-      }
-    
-      funding_source = user.add_funding_source(sourcehash)
-      funding_source.name.should eq 'My Checking Account - Checking'
-    end
-  end
-  
-  # "oauth_token": "",
-  # "funding_id": "",
-  # "pin": "",
-  # "amount": ""
-  
-  pending "Depositing funds to dwolla from funding source" do  
-  end
-  
-  pending "Withdrawing funds from dwolla to funding source" do
-  end
-  
-end

data/spec/dwolla/response/follow_redirects_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-require 'forwardable'
-
-describe Dwolla::Response::FollowRedirects do
-
- before do
-    @conn = Faraday.new do |b|
-      b.use Dwolla::Response::FollowRedirects
-      b.adapter :test do |stub|
-        stub.get('/') { [301, {'Location' => '/found'}, ''] }
-        stub.post('/create') { [302, {'Location' => '/'}, ''] }
-        stub.get('/found') { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
-        stub.get('/loop') { [302, {'Location' => '/loop'}, ''] }
-        stub.get('/temp') { [307, {'Location' => '/found'}, ''] }
-      end
-    end
-  end
-
-  extend Forwardable
-  def_delegators :@conn, :get, :post
-  
-  it 'follow one redirect' do
-    get('/').body.should == 'fin'
-  end
-  
-  it 'follow twice redirect' do
-    post('/create').body.should == 'fin'
-  end
-
-  it 'follows 307 redirects' do
-    get('/temp').body.should == 'fin'
-  end
-  
-  it 'has a redirect limit' do
-    expect { get('/loop') }.to raise_error(Dwolla::Response::RedirectLimitReached)
-  end  
-end
-

data/spec/dwolla/transaction_spec.rb

@@ -1,212 +0,0 @@
-require 'spec_helper'
-
-describe Dwolla::Transaction do
-  describe "send transaction" do
-    context "to a dwolla account" do
-      before do
-        @origin = double(:oauth_token => '1')
-        @destination = '2'
-        @destination_type = "dwolla"
-        @payload = { :amount => 200,
-                     :pin => '1234',
-                     :destinationId => '2',
-                     :destinationType => 'dwolla',
-                     :notes => "Sending a transaction",
-                     :oauth_token => '1' }
-
-        stub_post('/transactions/send').with(:body => MultiJson.dump(@payload)).to_return(
-          :body => fixture('send_transaction.json'))
-      end
-      it "should request the correct resource" do
-        transaction = Dwolla::Transaction.new(:origin => @origin,
-                                              :destination => @destination,
-                                              :destination_type => @destination_type,
-                                              :description => "Sending a transaction", 
-                                              :type => :send,
-                                              :amount => 200,
-                                              :pin => '1234')
-        transaction.execute
-
-        a_post('/transactions/send').
-          with(:body => MultiJson.dump(@payload)).should have_been_made
-      end
-
-      it "should fetch the id if transaction succesfull" do
-        transaction = Dwolla::Transaction.new(:origin => @origin,
-                                              :destination => @destination,
-                                              :destination_type => @destination_type,
-                                              :description => "Sending a transaction",
-                                              :type => :send,
-                                              :amount => 200,
-                                              :pin => '1234')
-
-        transaction.execute.should == 12345
-        transaction.id.should == 12345
-      end 
-    end
-    
-    context "to an email address" do
-      before do
-        @origin = double(:oauth_token => '1')
-        @destination = "user@example.com"
-        @destination_type = "email"
-        @payload = { :amount => 200,
-                     :pin => '1234',
-                     :destinationId => 'user@example.com',
-                     :destinationType => 'email',
-                     :notes => "Sending a transaction",
-                     :oauth_token => '1' }
-        stub_post('/transactions/send').with(:body => MultiJson.dump(@payload)).to_return(
-                       :body => fixture('send_transaction.json'))
-      end
-      it "should request the correct resource" do
-        transaction = Dwolla::Transaction.new(:origin => @origin,
-                                              :destination => @destination,
-                                              :destination_type => @destination_type,
-                                              :description => "Sending a transaction",
-                                              :type => :send,
-                                              :amount => 200,
-                                              :pin => '1234')
-                                              
-        transaction.execute
-
-        a_post('/transactions/send').
-          with(:body => MultiJson.dump(@payload)).should have_been_made
-      end
-
-      it "should fetch the id if transaction succesfull" do
-        transaction = Dwolla::Transaction.new(:origin => @origin,
-                                              :destination => @destination,
-                                              :destination_type => @destination_type,
-                                              :description => "Sending a transaction",
-                                              :type => :send,
-                                              :amount => 200,
-                                              :pin => '1234')
-
-        transaction.execute.should == 12345
-        transaction.id.should == 12345
-      end
-    end
-
-    context "and assume costs" do
-      before do
-        @origin = double(:oauth_token => '1')
-        @destination = "user@example.com"
-        @destination_type = "email"
-        @payload = { :amount => 200,
-                     :pin => '1234',
-                     :destinationId => 'user@example.com',
-                     :destinationType => 'email',
-                     :assumeCosts => true,
-                     :oauth_token => '1' }
-        stub_post('/transactions/send').with(:body => MultiJson.dump(@payload)).to_return(
-                       :body => fixture('send_transaction.json'))
-      end
-
-      it "should request the correct resource" do
-        transaction = Dwolla::Transaction.new(:origin => @origin,
-                                              :destination => @destination,
-                                              :destination_type => @destination_type,
-                                              :type => :send,
-                                              :amount => 200,
-                                              :pin => '1234',
-                                              :assume_costs => true )
-                                              
-        transaction.execute
-
-        a_post('/transactions/send').
-          with(:body => MultiJson.dump(@payload)).should have_been_made
-      end
-    end
-
-  end
-
-  describe "request transaction" do
-    context "from a dwolla account" do
-      before do
-        @origin = double(:oauth_token => '1')
-        @source = '2'
-        @source_type = 'dwolla'
-        @payload = { :amount => 200,
-                     :pin => '1234',
-                     :sourceId => '2',
-                     :sourceType => 'dwolla',
-                     :notes => "Sending a transaction",
-                     :oauth_token => '1' }
-
-        stub_post('/transactions/request').with(:body => MultiJson.dump(@payload)).to_return(
-          :body => fixture('request_transaction.json'))
-      end
-
-      it "should request the correct resource" do
-        transaction = Dwolla::Transaction.new(:origin => @origin,
-                                              :source => @source,
-                                              :source_type => @source_type,
-                                              :description => "Sending a transaction",
-                                              :type => :request,
-                                              :amount => 200,
-                                              :pin => '1234')
-        transaction.execute
-
-        a_post('/transactions/request').
-          with(:body => MultiJson.dump(@payload)).should have_been_made
-      end
-
-      it "should fetch the id if transaction succesfull" do
-        transaction = Dwolla::Transaction.new(:origin => @origin,
-                                              :source => @source,
-                                              :source_type => @source_type,
-                                              :description => "Sending a transaction",
-                                              :type => :request,
-                                              :amount => 200,
-                                              :pin => '1234')
-
-        transaction.execute.should == 12345
-        transaction.id.should == 12345
-      end
-    end
-    context "from an email address" do
-      before do
-        @origin = double(:oauth_token => '1')
-        @source = 'user@example.com'
-        @source_type = "email"
-        @payload = { :amount => 200,
-                     :pin => '1234',
-                     :sourceId => 'user@example.com',
-                     :sourceType => 'email',
-                     :notes => "Sending a transaction",
-                     :oauth_token => '1' }
-
-        stub_post('/transactions/request').with(:body => MultiJson.dump(@payload)).to_return(
-          :body => fixture('request_transaction.json'))
-      end
-
-      it "should request the correct resource" do
-        transaction = Dwolla::Transaction.new(:origin => @origin,
-                                              :source => @source,
-                                              :source_type => @source_type,
-                                              :description => "Sending a transaction",
-                                              :type => :request,
-                                              :amount => 200,
-                                              :pin => '1234')
-        transaction.execute
-
-        a_post('/transactions/request').
-          with(:body => MultiJson.dump(@payload)).should have_been_made
-      end
-
-      it "should fetch the id if transaction succesfull" do
-        transaction = Dwolla::Transaction.new(:origin => @origin,
-                                              :source => @source,
-                                              :source_type => @source_type,
-                                              :description => "Sending a transaction",
-                                              :type => :request,
-                                              :amount => 200,
-                                              :pin => '1234')
-
-        transaction.execute.should == 12345
-        transaction.id.should == 12345
-      end      
-    end
-  end
-end