plaid 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 177a3e175a0defda0b9303805fe7f1f841d161d6
-  data.tar.gz: addfdce9ab4abe67eb4fa0478a83e56e5e09172e
+  metadata.gz: 3b2355e11af0826a2ace7a6c8f01c439927d68d4
+  data.tar.gz: ec087e866397828a734a808fa75e2400789ea8fb
 SHA512:
-  metadata.gz: 578a30e11a1c222c77a8c8cc6d5877400cd77d25cca5d898ade5e2f2fc5092d2fb248c874676999ab134911804724c7a23e3ef96af53b755056427c71cabe92c
-  data.tar.gz: e0e2213f052cb3641f715603ee0991cb24ee1edae76c5d913ecc3aabcddaf6bd7be5b10cd4841c4aeceff5209b6477a48080529ab12faaa25b35a2b9f525d674
+  metadata.gz: 29fe226dcbb38dc8987d02996c827a9c47d9854c1d782ae4b7de56020b491b2dafbbd5003da43682bf5d5f6d62896f0576e8b841109ffa2cf2a1369e3866ba8c
+  data.tar.gz: a8181aaf03e10ebc3029d4535c979a9a988381714f5558cda88909190e8388753715534659b64fef540b689a45681bf6d51d22355ef781aeec1c797ee8850945

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.1.3

data/README.md

@@ -1,6 +1,14 @@
-# Plaid
+# Plaid [![Build Status](https://travis-ci.org/plaid/plaid-ruby.svg?branch=release_v_1.0.0)](https://travis-ci.org/plaid/plaid-ruby)
 
-TODO: Write a gem description
+Ruby bindings for the Plaid API
+
+## Notes
+
+Latest stable version: **1.0.0**
+
+Last stable version: 0.1.6
+
+**Warning: If you have been using any version < 1 please switch to the correct branch (V0.1.6). Installing without specifying a version from RubyGems results in V1.0.0 build. **
 
 ## Installation
 
@@ -10,22 +18,40 @@ Add this line to your application's Gemfile:
 gem 'plaid'
 ```
 
-And then execute:
+And install
 
     $ bundle
 
-Or install it yourself as:
+Or install it system wide as:
 
     $ gem install plaid
 
 ## Usage
 
-TODO: Write usage instructions here
+Please read the great documentation at http://plaid.com/docs/ for more information.
+
+Configure the gem with your customer id, secret key, and the environment path you would like to use.
+
+```ruby
+Plaid.config do |p|
+    p.customer_id = ['test_id']
+    p.secret = ['test_secret']
+    p.environment_location = ['https://tartan.plaid.com/']
+end
+```
+
+Authenticate a user to your desired level of api access (auth / connect).
+
+```ruby
+user = Plaid.auth('auth','plaid_test','plaid_good','wells')
+```
+
+## Learn More
+
+Learn about the full functionality of the library on our [Wiki](https://github.com/plaid/plaid-ruby/wiki)
+
+## Contribute
 
-## Contributing
+We highly encourage helping out with the gem. Either adding more tests, building new helper classes, fixing bugs, or anything to increase overall quality.
 
-1. Fork it ( https://github.com/[my-github-username]/plaid/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
+Learn more about best practices, submitting a pull request, and rules for the build on our [Wiki](https://github.com/plaid/plaid-ruby/wiki/Contribute!)

data/lib/plaid.rb

@@ -8,10 +8,7 @@ require 'plaid/institution/institution'
 require 'plaid/category/category'
 
 module Plaid
-  # Define an instance of the gem thus responding with one customer at a time
   class << self
-    # Include the SDK methods
-
     # Configures the gem with the public, private, and environment vars
     include Plaid::Configure
 
@@ -22,21 +19,23 @@ module Plaid
     include Plaid::Auth
 
     # Builds the user object and returns on successful authentication
-    def user(res)
+    def user(res,api_level=nil)
       @user = Plaid::User.new
-      @user.new(res)
+      @user.new(res,api_level)
     end
 
     # Builds an institution object and returns when the institution details exist
-    def institution(res)
+    def institution(id=nil)
       @institution = Plaid::Institution.new
-      @institution.new(res)
+      res = self.get('institutions',id)
+      id.nil? ? @institution.instantiate_all_institutions(res) : @institution.instantiate_one_institution(res)
     end
 
     # Builds an institution object and returns when the category details exist
-    def category(res)
+    def category(id=nil)
       @category = Plaid::Category.new
-      @category.new(res)
+      res = self.get('categories',id)
+      id.nil? ? @category.instantiate_all_categories(res) : @category.instantiate_one_category(res)
     end
 
   end

data/lib/plaid/auth.rb

@@ -2,8 +2,9 @@ module Plaid
   module Auth
       def auth(api_level,username,password,type)
         begin
-          res = self.post(api_level,username,password,type)
-          self.user(res)
+          options = {username:username,password:password,type:type}
+          res = self.post(api_level,options)
+          self.user(res,api_level)
         rescue => e
           error_handler(e)
         end

data/lib/plaid/category/category.rb

@@ -3,27 +3,20 @@ module Plaid
   class Category
     include Plaid::Util
 
-    attr_accessor(:type, :hierarchy, :id)
-
-    # Returns an instantiated category object, or an array of all categories
-    def new(id=nil)
-      res = get('categories',id)
-      id.nil? ? cat = instantiate_all_categories(res) : cat = instantiate_one_category(res)
-      cat
-    end
+    attr_accessor(:type, :hierarchy, :id, :cat_array)
 
     def instantiate_all_categories(res)
-      cat_array = []
-      res['category'].each do |cat|
-        @category = Category.new
-        cat_array << @category.build_category(cat)
+      self.cat_array = []
+      res.each do |cat|
+        category = Category.new
+        self.cat_array << category.build_category(cat)
       end
-      cat_array
+      self.cat_array
     end
 
     def instantiate_one_category(res)
-      @category = Category.new
-      @category.build_category(res)
+      self.build_category(res)
+      self
     end
 
     protected

data/lib/plaid/institution/institution.rb

@@ -3,33 +3,26 @@ module Plaid
   class Institution
     include Plaid::Util
 
-    attr_accessor(:id, :name, :type, :has_mfa, :mfa)
-
-    # Returns an instantiated category object, or an array of all categories
-    def new(id=nil)
-      res = get('institutions',id)
-      id.nil? ? cat = instantiate_all_institutions(res) : cat = instantiate_one_institution(res)
-      cat
-    end
+    attr_accessor(:id, :name, :type, :has_mfa, :mfa, :inst_array)
 
     def instantiate_all_institutions(res)
-      inst_array = []
-      res['institution'].each do |inst|
-        @institution = Institution.new
-        inst_array << @institution.build_institution(inst)
+      self.inst_array = []
+      res.each do |inst|
+        institution = Institution.new
+        inst_array << institution.build_institution(inst)
       end
-      inst_array
+      self.inst_array
     end
 
     def instantiate_one_institution(res)
-      @category = Institution.new
-      @category.build_institution(res)
+      self.build_institution(res)
+      self
     end
 
     protected
 
-    def build_institution(cat)
-      self.id = cat['id'], self.name = cat['name'], self.type = cat['type'], self.has_mfa = cat['has_mfa'], self.mfa = cat['mfa']
+    def build_institution(inst)
+      self.id = inst['id'], self.name = inst['name'], self.type = inst['type'], self.has_mfa =inst['has_mfa'], self.mfa = inst['mfa']
     end
 
   end

data/lib/plaid/user/user.rb

@@ -2,32 +2,74 @@ require_relative 'account/account'
 require_relative 'transaction/transaction'
 require 'plaid/util'
 module Plaid
-  class User
+  class Plaid::User
     include Plaid::Util
 
     # Define user vars
-    attr_accessor(:accounts, :transactions, :access_token)
+    attr_accessor(:accounts, :transactions, :access_token, :permissions, :api_res, :pending_mfa_questions)
 
     def initialize
       self.accounts = []
       self.transactions = []
+      self.permissions = []
       self.access_token = ''
+      self.api_res = ''
     end
 
     # Instantiate a new user with the results of the successful API call
     # Build an array of nested accounts, and return self if successful
-    def new(res)
+    def new(res,api_level=nil)
+      build_user(res,api_level)
+    end
+
+    def mfa_authentication(auth,type)
+      auth_path = self.permissions[0] + '/step'
+      res = Plaid.post(auth_path,{mfa:auth,access_token:self.access_token,type:type})
+      self.accounts = [], self.transactions = []
+      update_user(res)
+    end
+
+    def get_auth
+      if self.permissions.include? 'auth'
+        res = Plaid.post('auth/get',{access_token:self.access_token})
+        build_user(res)
+      else
+        false
+      end
+    end
+
+    def get_connect
+      if self.permissions.include? 'connect'
+        res = Plaid.post('connect/get',{access_token:self.access_token})
+        build_user(res)
+      else
+        false
+      end
+    end
+
+    def upgrade
+      upgrade_to = 'auth' unless self.permissions.include? 'auth'
+      upgrade_to = 'connect' unless self.permissions.include? 'connect'
+      res = Plaid.post('upgrade',{access_token:self.access_token,upgrade_to:upgrade_to})
+      build_user(res)
+    end
+
+    protected
+
+    def build_user(res,api_level=nil)
       begin
-        self.access_token = res['access_token']
-        if res['msg'].nil?
+        if res[:msg].nil?
           res['accounts'].each do |account|
             self.accounts << new_account(account)
           end if res['accounts']
           res['transactions'].each do |transaction|
             self.transactions << new_transaction(transaction)
           end if res['transactions']
+          self.permissions << api_level
+          self.access_token = res['access_token']
+          self.api_res = 'success'
         else
-          self.accounts = res.msg, self.transactions = res.msg
+          self.pending_mfa_questions = res[:body], self.accounts = res[:msg], self.transactions = res[:msg], self.permissions << api_level, self.access_token = res[:body]['access_token'], self.api_res = res[:msg]
         end
       rescue => e
         error_handler(e)
@@ -36,7 +78,27 @@ module Plaid
       end
     end
 
-    protected
+    def update_user(res,api_level=nil)
+      begin
+        if res[:msg].nil?
+          res['accounts'].each do |account|
+            self.accounts << new_account(account)
+          end if res['accounts']
+          res['transactions'].each do |transaction|
+            self.transactions << new_transaction(transaction)
+          end if res['transactions']
+          self.permissions << api_level
+          self.api_res = 'success'
+          self.pending_mfa_questions = ''
+        else
+          self.pending_mfa_questions = res[:body]
+        end
+      rescue => e
+        error_handler(e)
+      else
+        self
+      end
+    end
 
     # Instantiate and build a new account object, return this to the accounts array
     def new_account(account)

data/lib/plaid/util.rb

@@ -4,16 +4,17 @@ require 'uri'
 module Plaid
   module Util
 
-    def post(path,username,password,type,options={})
+    def post(path,options={})
       uri = build_uri(path)
-      res = Net::HTTP.post_form(uri, {client_id: self.instance_variable_get(:'@customer_id') ,secret: self.instance_variable_get(:'@secret'), username: username, password: password, type: type})
+      options.merge!({client_id: self.instance_variable_get(:'@customer_id') ,secret: self.instance_variable_get(:'@secret')})
+      res = Net::HTTP.post_form(uri,options)
       parse_response(res)
     end
 
     def get(path,id=nil)
       uri = build_uri(path,id)
       res = Net::HTTP.get(uri)
-      parse_response(res)
+      JSON.parse(res)
     end
 
     def error_handler(err,res=nil)
@@ -26,6 +27,10 @@ module Plaid
           raise 'Request Failed'
         when 'Not Found'
           raise 'Not Found'
+        when 'Institution not supported'
+          raise 'Institution not supported'
+        when 'Corrupted token'
+          raise 'It appears that the access_token has been corrupted'
         else
           raise err
       end
@@ -33,31 +38,31 @@ module Plaid
 
     protected
 
-    def build_uri(path,id=nil)
-      id ? URI.parse(self.instance_variable_get(:'@environment_location') + path + id) :
-           URI.parse(self.instance_variable_get(:'@environment_location') + path)
+    def build_uri(path,option=nil)
+      path = path + '/' + option unless option.nil?
+      URI.parse(self.instance_variable_get(:'@environment_location') + path)
     end
 
     private
 
     def parse_response(res)
       body = JSON.parse(res.body)
-      case res.code
-        when '200'
+      case res.code.delete('.').to_i
+        when 200
           return body
-        when '201'
+        when 201
           return { msg: 'Requires further authentication', body: body}
-        when '400'
+        when 400
           error_handler('Bad Request',res)
-        when '401'
+        when 401
+          error_handler('Institution not supported',res) if body['code'] == 1108
+          error_handler('Corrupted token',res) if body['code'] == 1105
+          error_handler('Not Found',res) if body['code'] == 1501
           error_handler('Unauthorized',res)
-        when '402'
-          if body['code'] == 1205
-            return { msg: 'User account is locked', body: body }
-          else
-            error_handler('Request Failed',res)
-          end
-        when '404'
+        when 402
+          return {msg: 'User account is locked', body: body} if body['code'] == 1205
+          error_handler('Request Failed', res)
+        when 404
           error_handler('Not Found',res)
         else
           error_handler('Server Error',res)

data/lib/plaid/version.rb

@@ -1,3 +1,3 @@
 module Plaid
-  VERSION = '1.0.0'
+  VERSION = '1.0.1'
 end

data/plaid.gemspec

@@ -11,6 +11,7 @@ Gem::Specification.new do |spec|
   spec.description   = 'Ruby gem wrapper for the Plaid API. Read more at the homepage, the wiki, or the plaid documentation.'
   spec.homepage      = 'https://github.com/plaid/plaid-ruby'
   spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 2.1.3'
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }

data/spec/plaid_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper.rb'
 ########## Plaid specs ##########
 describe Plaid do
+
   # Configuration specs - used in gem configuration
   describe '.config' do
     context 'has valid dev keys' do
@@ -10,7 +11,7 @@ describe Plaid do
         p.environment_location = 'https://tartan.plaid.com/'
       end
       res = Plaid.auth('connect','plaid_test','plaid_good','wells')
-      it { expect(res).to be instance_of Plaid::User }
+      it { expect(res).to be_instance_of Plaid::User }
     end
 
     context 'has valid production keys' do
@@ -19,9 +20,8 @@ describe Plaid do
         p.secret = 'test_secret'
         p.environment_location = 'https://api.plaid.com/'
       end
-      #TODO: Test production level credentials
       res = Plaid.auth('connect','plaid_test','plaid_good','wells')
-      it { expect(res).to raise_error }
+      it { expect(res).to be_instance_of Plaid::User }
     end
 
     context 'has invalid dev keys' do
@@ -30,7 +30,7 @@ describe Plaid do
         p.secret = 'test_bad'
         p.environment_location = 'https://tartan.plaid.com/'
       end
-      it { expect(Plaid.auth('connect','plaid_test','plaid_good','wells')).to raise_error }
+      it { expect{Plaid.auth('connect','plaid_bad','plaid_bad','wells')}.to raise_error }
     end
 
     context 'has invalid production keys' do
@@ -39,7 +39,7 @@ describe Plaid do
         p.secret = 'test_bad'
         p.environment_location = 'https://api.plaid.com/'
       end
-      it { expect(Plaid.auth('connect','plaid_test','plaid_good','wells')).to raise_error }
+      it { expect{Plaid.auth('connect','plaid_bad','plaid_bad','wells')}.to raise_error }
     end
   end
 
@@ -54,7 +54,7 @@ describe Plaid do
         p.environment_location = 'https://tartan.plaid.com/'
       end
       user = Plaid.auth('connect','plaid_test','plaid_good','wells')
-      it { expect(user.accounts.blank?).to be_false }
+      it { expect(user.accounts.empty?).to be_falsey }
     end
 
     context 'has correct credentials for single factor auth, authenticates to the auth path' do
@@ -64,7 +64,7 @@ describe Plaid do
         p.environment_location = 'https://tartan.plaid.com/'
       end
       user = Plaid.auth('auth','plaid_test','plaid_good','wells')
-      it { expect(user.accounts[0].numbers.nil?).to be_false }
+      it { expect(user.accounts[0].numbers.nil?).to be_falsey }
     end
 
     context 'has correct username, but incorrect password for single factor auth under auth path' do
@@ -73,7 +73,7 @@ describe Plaid do
         p.secret = 'test_secret'
         p.environment_location = 'https://tartan.plaid.com/'
       end
-      it { expect(Plaid.auth('auth','plaid_test','plaid_bad','wells')).to raise_error }
+      it { expect{Plaid.auth('auth','plaid_test','plaid_bad','wells')}.to raise_error }
     end
 
     context 'has incorrect username under auth path' do
@@ -82,7 +82,7 @@ describe Plaid do
         p.secret = 'test_secret'
         p.environment_location = 'https://tartan.plaid.com/'
       end
-      it { expect(Plaid.auth('auth','plaid_bad','plaid_bad','wells')).to raise_error }
+      it { expect{Plaid.auth('auth','plaid_bad','plaid_bad','wells')}.to raise_error }
     end
 
     context 'has correct username, but incorrect password for single factor auth under connect path' do
@@ -91,7 +91,7 @@ describe Plaid do
         p.secret = 'test_secret'
         p.environment_location = 'https://tartan.plaid.com/'
       end
-      it { expect(Plaid.auth('connect','plaid_test','plaid_bad','wells')).to raise_error }
+      it { expect{Plaid.auth('connect','plaid_test','plaid_bad','wells')}.to raise_error }
     end
 
     context 'has incorrect username under connect path' do
@@ -100,7 +100,7 @@ describe Plaid do
         p.secret = 'test_secret'
         p.environment_location = 'https://tartan.plaid.com/'
       end
-      it { expect(Plaid.auth('connect','plaid_bad','plaid_bad','wells')).to raise_error }
+      it { expect{Plaid.auth('connect','plaid_bad','plaid_bad','wells')}.to raise_error }
     end
 
     context 'has to enter MFA credentials' do
@@ -109,8 +109,8 @@ describe Plaid do
         p.secret = 'test_secret'
         p.environment_location = 'https://tartan.plaid.com/'
       end
-      user = Plaid.auth('connect','plaid_selections', 'plaid_good','wells')
-      it { expect(user.accounts).to eq 'Requires further authentication' }
+      user = Plaid.auth('connect','plaid_selections', 'plaid_good','bofa')
+      it { expect(user.api_res).to eq 'Requires further authentication' }
     end
 
     context 'enters correct information with locked account' do
@@ -120,133 +120,165 @@ describe Plaid do
         p.environment_location = 'https://tartan.plaid.com/'
       end
       user = Plaid.auth('connect','plaid_selections', 'plaid_locked','wells')
-      it { expect(user.accounts).to eq 'User account is locked' }
+      it { expect(user.api_res).to eq 'User account is locked' }
     end
   end
 
-=begin
-  TODO: Finish up these tests
   # Institution specs
-  describe Plaid::Institution do
+  describe '#Institution' do
+    context 'when a single institution is found' do
+      Plaid.config do |p|
+        p.customer_id = 'test_id'
+        p.secret = 'test_secret'
+        p.environment_location = 'https://tartan.plaid.com/'
+      end
+      institution = Plaid.institution('5301a93ac140de84910000e0')
+      it { expect(institution.class).to eq(Plaid::Institution) }
+    end
 
-    context 'when institution is found' do
+    context 'when all institutions are found' do
       Plaid.config do |p|
         p.customer_id = 'test_id'
         p.secret = 'test_secret'
         p.environment_location = 'https://tartan.plaid.com/'
       end
-      institution = Plaid.institution('amex')
-      it { expect(institution).to be instance_of Plaid::Institution }
+      institution = Plaid.institution
+      it { expect(institution).to be_kind_of(Array) }
     end
 
+=begin TODO: Get this test passing
     context 'when institution is not found' do
       Plaid.config do |p|
         p.customer_id = 'test_id'
         p.secret = 'test_secret'
         p.environment_location = 'https://tartan.plaid.com/'
       end
-      it { expect(Plaid.institution('dumb_bank')).to raise_error }
+      res = Plaid.institution('dumb_bank')
+      it { expect(res).to eq('Bank not found') }
     end
+=end
   end
 
   # Category specs
-  describe Plaid::Category do
-
-    context 'when category is found' do
+  describe '#Category' do
+    context 'when a single category is found' do
       Plaid.config do |p|
         p.customer_id = 'test_id'
         p.secret = 'test_secret'
         p.environment_location = 'https://tartan.plaid.com/'
       end
       category = Plaid.category('17001013')
-      it { expect(category).to be instance_of Plaid::Category }
+      it { expect(category.class).to eq (Plaid::Category) }
     end
 
+    context 'when all categories are found' do
+      Plaid.config do |p|
+        p.customer_id = 'test_id'
+        p.secret = 'test_secret'
+        p.environment_location = 'https://tartan.plaid.com/'
+      end
+      category = Plaid.category
+      it { expect(category).to be_kind_of(Array)}
+    end
+
+=begin TODO: Get this test passing
     context 'when category is not found' do
       Plaid.config do |p|
         p.customer_id = 'test_id'
         p.secret = 'test_secret'
         p.environment_location = 'https://tartan.plaid.com/'
       end
-      it { expect(Plaid.category('dumb_cat')).to raise_error }
+      it { expect { Plaid.category('dumb_cat') }.to raise_error }
     end
+=end
 
   end
-end
-
-########## Plaid instantiated user specs ##########
-
-describe Plaid::User do
-  subject(:success_user) { Plaid.auth('connect','plaid_test','plaid_good','wells') }
-  subject(:mfa_user) { Plaid.auth('connect','plaid_selections', 'plaid_good','wells') }
+  ########## Plaid instantiated user specs ##########
+
+  describe '#User' do
+    # MFA specs - after user is instantiated,
+    describe '#mfa_authentication' do
+
+      context 'enters correct credentials for MFA auth and authenticates' do
+        Plaid.config do |p|
+          p.customer_id = 'test_id'
+          p.secret = 'test_secret'
+          p.environment_location = 'https://tartan.plaid.com/'
+        end
+        new_mfa_user = Plaid.auth('connect','plaid_selections', 'plaid_good','bofa')
+        new_mfa_user.mfa_authentication('tomato','bofa')
+        it { expect(new_mfa_user.accounts).to be_truthy }
+      end
 
-  # MFA specs - after user is instantiated,
-  describe '#mfa_authentication' do
-    context 'has to enter another round of MFA credentials' do
-      res = user.mfa_authenticaiton('again')
-      expect(res).to eq 'Another round requested'
-    end
+      context 'has to enter another round of MFA credentials' do
+        Plaid.config do |p|
+          p.customer_id = 'test_id'
+          p.secret = 'test_secret'
+          p.environment_location = 'https://tartan.plaid.com/'
+        end
+        mfa_again = Plaid.auth('connect','plaid_selections', 'plaid_good','bofa')
+        mfa_again.mfa_authentication('again','bofa')
+        it { expect(mfa_again.api_res).to eq 'Requires further authentication' }
+      end
 
-    context 'enters correct credentials for MFA auth and authenticates' do
-      user.mfa_authentication('tomato')
-      expect(user.accounts).to be_truthy
+      context 'enters incorrect credentials for MFA auth' do
+        Plaid.config do |p|
+          p.customer_id = 'test_id'
+          p.secret = 'test_secret'
+          p.environment_location = 'https://tartan.plaid.com/'
+        end
+        mfa_user = Plaid.auth('connect','plaid_selections', 'plaid_good','bofa')
+        mfa_user.mfa_authentication('tomato','bofa')
+        mfa_user = Plaid.auth('connect','plaid_selections', 'plaid_good','bofa')
+        it { expect { mfa_user.mfa_authentication('bad','bofa') }.to raise_error }
+      end
     end
 
-    context 'enters incorrect credentials for MFA auth' do
-      res = user.mfa_authentication('bad')
-      expect(res).to eq 'Incorrect answer to MFA'
-    end
-  end
+    # Auth specs
+    describe '#get_auth' do
+      auth_user = Plaid.auth('auth','plaid_test','plaid_good','wells')
+      connect_user = Plaid.auth('connect','plaid_test','plaid_good','wells')
 
-  # Upgrade specs - either pass or fails
-  describe '#upgrade' do
-    context 'auth upgrade is successful' do
-      user.upgrade('auth')
-      expect(user.auth).to be true
-    end
+      context 'has access and returns accounts' do
+        it { expect(auth_user.permissions[0]).to eq('auth') }
+      end
 
-    context 'auth upgrade failed' do
-      user.upgrade('auth')
-      expect(user.auth).to be false
+      context 'does not have access to auth' do
+        it{ expect(connect_user.permissions.include? 'auth' ).to be false }
+      end
     end
 
-    context 'connect upgrade is successful' do
-      user.upgrade('connect')
-      expect(user.auth).to be true
-    end
+    # Connect specs
+    describe '#get_connect' do
+      auth_user = Plaid.auth('auth','plaid_test','plaid_good','wells')
+      connect_user = Plaid.auth('connect','plaid_test','plaid_good','wells')
 
-    context 'connect upgrade failed' do
-      user.upgrade('connect')
-      expect(user.auth).to be false
-    end
-  end
+      context 'has access and returns accounts' do
+        it { expect(connect_user.permissions[0]).to eq('connect') }
+      end
 
-  # Auth specs
-  describe '#auth' do
-    context 'has access and returns accounts' do
-      auth = user.auth
-      expect(auth).to be true
-      expect(user.accounts).to be_truthy
+      context 'does not have access to auth' do
+        it{ expect(auth_user.permissions.include? 'connect' ).to be false }
+      end
     end
 
-    context 'does not have access to auth' do
-      auth = user.auth
-      expect(auth).to be false
-    end
-  end
+    # Upgrade specs - either pass or fails
+=begin TODO: Write upgrade methods to pass without paying
+    describe '#upgrade' do
+      auth_user = Plaid.auth('auth','plaid_test','plaid_good','wells')
+      connect_user = Plaid.auth('connect','plaid_test','plaid_good','wells')
 
-  # Connect specs
-  describe '#connect' do
-    context 'has access and returns accounts' do
-      expect(user.connect).to be true
-      expect(user.transactions).to be_truthy
-    end
+      context 'auth upgrade is successful' do
+        connect_user.upgrade
+        it { expect(connect_user.get_auth).to be_truthy }
+      end
 
-    context 'does not have access to auth' do
-      expect(user.connect).to be false
+      context 'connect upgrade is successful' do
+        auth_user.upgrade
+        it { expect(auth_user.get_connect).to be_truthy }
+      end
     end
-  end
-
 =end
 
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plaid
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Justin Crites
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-22 00:00:00.000000000 Z
+date: 2015-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -61,6 +61,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -90,7 +91,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.1.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="