old_plaid 1.7.1

data/spec/plaid/config_spec.rb

@@ -0,0 +1,67 @@
+describe 'OldPlaid.config' do
+  around(:each) do |example|
+    old_customer_id          = OldPlaid.customer_id
+    old_secret               = OldPlaid.secret
+    old_environment_location = OldPlaid.environment_location
+
+    OldPlaid.config do |p|
+      p.customer_id          = customer_id
+      p.secret               = secret
+      p.environment_location = environment_location
+    end
+
+    example.run
+
+    OldPlaid.config do |p|
+      p.customer_id          = old_customer_id
+      p.secret               = old_secret
+      p.environment_location = old_environment_location
+    end
+  end
+
+  let(:customer_id) { 'test_id' }
+  let(:secret)      { 'test_secret' }
+  let(:dev_url)  { 'https://tartan.plaid.com/' }
+  let(:prod_url) { 'https://api.plaid.com/' }
+
+
+  let(:user) { OldPlaid.add_user('connect', 'plaid_test', 'plaid_good', 'wells') }
+
+  context ':environment_location' do
+    context 'with trailing slash' do
+      let(:environment_location) { 'http://example.org/' }
+      it 'leaves it as-is' do
+        expect(OldPlaid.environment_location).to eql(environment_location)
+      end
+    end
+
+    context 'without trailing slash' do
+      let(:environment_location) { 'http://example.org' }
+      it 'adds a trailing slash' do
+        expect(OldPlaid.environment_location).to eql(environment_location + '/')
+      end
+    end
+  end
+
+  context 'has valid dev keys' do
+    let(:environment_location) { dev_url }
+    it { expect(user).to be_instance_of OldPlaid::User }
+  end
+
+  context 'has valid production keys' do
+    let(:environment_location) { prod_url }
+    it { expect(user).to be_instance_of OldPlaid::User }
+  end
+
+  context 'has invalid dev keys' do
+    let(:secret) { 'test_bad' }
+    let(:environment_location) { dev_url }
+    it { expect { user }.to raise_error(OldPlaid::Unauthorized, 'secret or client_id invalid') }
+  end
+
+  context 'has invalid production keys' do
+    let(:secret) { 'test_bad' }
+    let(:environment_location) { prod_url }
+    it { expect { user }.to raise_error(OldPlaid::Unauthorized, 'secret or client_id invalid') }
+  end
+end

data/spec/plaid/connection_spec.rb

@@ -0,0 +1,191 @@
+describe OldPlaid::Connection do
+  let(:stub_url) { "https://tartan.plaid.com/testing" }
+  let(:bad_req_response) {  {"code" => 1005, "message" => "invalid credentials", "resolve" => "The username or password provided is not correct."}.to_json }
+  let(:unauth_response) { {"code" => 1105, "message" => "bad access_token", "resolve" => "This access_token appears to be corrupted."}.to_json }
+  let(:req_fail_response) {  {"code" => 1200, "message" => "invalid credentials", "resolve" => "The username or password provided is not correct."}.to_json }
+  let(:req_not_found) {  {"code" =>  1600, "message" => "product not found", "resolve" => "This product doesn't exist yet, we're actually not sure how you reached this error..."}.to_json }
+
+  describe "#post" do
+    it "sends a post request" do
+      stub = stub_request(:post, stub_url).to_return({:body => {"response" => "OK"}.to_json})
+      OldPlaid::Connection.post("testing")
+      expect(stub).to have_requested(:post, stub_url)
+    end
+
+    it "returns response on 200 response" do
+      stub = stub_request(:post, stub_url).to_return({:body => {"response" => "OK"}.to_json})
+      response = OldPlaid::Connection.post("testing")
+      expect(response).to eq({"response" => "OK"})
+    end
+
+    it "returns message on 201 response" do
+      stub = stub_request(:post, stub_url).to_return(status: 201, body: {"response" => "OK"}.to_json)
+      response = OldPlaid::Connection.post("testing")
+      expect(response).to eq({:msg => "Requires further authentication", :body => {"response" => "OK"}})
+    end
+
+    it "throws OldPlaid::BadRequest on 400 response" do
+      stub = stub_request(:post, stub_url).to_return(status: 400, body: bad_req_response)
+      expect { OldPlaid::Connection.post("testing") }.to raise_error(OldPlaid::BadRequest, "invalid credentials")
+    end
+
+    it "throws OldPlaid::Unauthorized on 401 response" do
+      stub = stub_request(:post, stub_url).to_return(status: 401, body: unauth_response)
+      expect { OldPlaid::Connection.post("testing") }.to raise_error(OldPlaid::Unauthorized, "bad access_token")
+    end
+
+    it "throws OldPlaid::RequestFailed on 402 response" do
+      stub = stub_request(:post, stub_url).to_return(status: 402, body: req_fail_response)
+      expect { OldPlaid::Connection.post("testing") }.to raise_error(OldPlaid::RequestFailed, "invalid credentials")
+    end
+
+    it "throws a OldPlaid::NotFound on 404 response" do
+      stub = stub_request(:post, stub_url).to_return(status: 404, body: req_not_found)
+      expect { OldPlaid::Connection.post("testing") }.to raise_error(OldPlaid::NotFound, "product not found")
+    end
+
+    it "throws a OldPlaid::ServerError on empty response" do
+      stub = stub_request(:post, stub_url).to_return(status: 504, body: '')
+      expect { OldPlaid::Connection.post("testing") }.to raise_error(OldPlaid::ServerError, '')
+    end
+  end
+
+  describe "#get" do
+    it "sends a get request" do
+      stub = stub_request(:get, stub_url).to_return({:body => {"response" => "OK"}.to_json})
+      OldPlaid::Connection.get("testing")
+      expect(stub).to have_requested(:get, stub_url)
+    end
+
+    it "returns response when no code available" do
+      stub = stub_request(:get, stub_url).to_return({:body => {"response" => "OK"}.to_json})
+      response = OldPlaid::Connection.get("testing")
+      expect(response).to eq({"response" => "OK"})
+    end
+
+    it "returns response when code not [1301, 1401, 1501, 1601]" do
+      stub = stub_request(:get, stub_url).to_return({:body => {"code" => 1502, "response" => "OK"}.to_json})
+      response = OldPlaid::Connection.get("testing")
+      expect(response).to eq({"code" => 1502, "response" => "OK"})
+    end
+
+    it "throws 404 for 1301 code" do
+      stub = stub_request(:get, stub_url).to_return({:body => {"code" => 1301, "message" => "Doesn't matter", "resolve" => "Yep."}.to_json})
+      expect { OldPlaid::Connection.get("testing")}.to raise_error(OldPlaid::NotFound, "Doesn't matter")
+    end
+
+    it "throws 404 for 1401 code" do
+      stub = stub_request(:get, stub_url).to_return({:body => {"code" => 1401, "message" => "Doesn't matter", "resolve" => "Yep."}.to_json})
+      expect { OldPlaid::Connection.get("testing")}.to raise_error(OldPlaid::NotFound, "Doesn't matter")
+    end
+
+    it "throws 404 for 1501 code" do
+      stub = stub_request(:get, stub_url).to_return({:body => {"code" => 1501, "message" => "Doesn't matter", "resolve" => "Yep."}.to_json})
+      expect { OldPlaid::Connection.get("testing")}.to raise_error(OldPlaid::NotFound, "Doesn't matter")
+    end
+
+    it "throws 404 for 1601 code" do
+      stub = stub_request(:get, stub_url).to_return({:body => {"code" => 1601, "message" => "Doesn't matter", "resolve" => "Yep."}.to_json})
+      expect { OldPlaid::Connection.get("testing")}.to raise_error(OldPlaid::NotFound, "Doesn't matter")
+    end
+
+  end
+
+  describe "#secure_get" do
+    it "sends a secure get request" do
+      stub = stub_request(:get, stub_url).to_return({:body => {"response" => "OK"}.to_json})
+      OldPlaid::Connection.secure_get("testing", "test_wells")
+      expect(stub).to have_requested(:get, stub_url).with(:body => {:access_token => "test_wells"})
+    end
+
+    it "returns response on 200 response" do
+      stub = stub_request(:get, stub_url).to_return({:body => {"response" => "OK"}.to_json})
+      response = OldPlaid::Connection.secure_get("testing", "test_wells")
+      expect(response).to eq({"response" => "OK"})
+    end
+
+    it "returns message on 201 response" do
+      stub = stub_request(:get, stub_url).to_return(status: 201, body: {"response" => "OK"}.to_json)
+      response = OldPlaid::Connection.secure_get("testing", "test_wells")
+      expect(response).to eq({:msg => "Requires further authentication", :body => {"response" => "OK"}})
+    end
+
+    it "throws OldPlaid::BadRequest on 400 response" do
+      stub = stub_request(:get, stub_url).to_return(status: 400, body: bad_req_response)
+      expect { OldPlaid::Connection.secure_get("testing", "test_wells") }.to raise_error(OldPlaid::BadRequest, "invalid credentials")
+    end
+
+    it "throws OldPlaid::Unauthorized on 401 response" do
+      stub = stub_request(:get, stub_url).to_return(status: 401, body: unauth_response)
+      expect { OldPlaid::Connection.secure_get("testing", "test_wells") }.to raise_error(OldPlaid::Unauthorized, "bad access_token")
+    end
+
+    it "throws OldPlaid::RequestFailed on 402 response" do
+      stub = stub_request(:get, stub_url).to_return(status: 402, body: req_fail_response)
+      expect { OldPlaid::Connection.secure_get("testing", "test_wells") }.to raise_error(OldPlaid::RequestFailed, "invalid credentials")
+    end
+
+    it "throws a OldPlaid::NotFound on 404 response" do
+      stub = stub_request(:get, stub_url).to_return(status: 404, body: req_not_found)
+      expect { OldPlaid::Connection.secure_get("testing", "test_wells") }.to raise_error(OldPlaid::NotFound, "product not found")
+    end
+
+    it "throws a OldPlaid::ServerError on empty response" do
+      stub = stub_request(:get, stub_url).to_return(status: 504, body: '')
+      expect { OldPlaid::Connection.secure_get("testing", "test_wells") }.to raise_error(OldPlaid::ServerError, '')
+    end
+  end
+
+  describe "#patch" do
+    it "sends a patch request" do
+      stub = stub_request(:patch, stub_url).to_return({:body => {"response" => "OK"}.to_json})
+      OldPlaid::Connection.patch("testing")
+      expect(stub).to have_requested(:patch, stub_url)
+    end
+
+    it "returns response on 200 response" do
+      stub = stub_request(:patch, stub_url).to_return({:body => {"response" => "OK"}.to_json})
+      response = OldPlaid::Connection.patch("testing")
+      expect(response).to eq({"response" => "OK"})
+    end
+
+    it "returns message on 201 response" do
+      stub = stub_request(:patch, stub_url).to_return(status: 201, body: {"response" => "OK"}.to_json)
+      response = OldPlaid::Connection.patch("testing")
+      expect(response).to eq({:msg => "Requires further authentication", :body => {"response" => "OK"}})
+    end
+
+    it "throws OldPlaid::BadRequest on 400 response" do
+      stub = stub_request(:patch, stub_url).to_return(status: 400, body: bad_req_response)
+      expect { OldPlaid::Connection.patch("testing") }.to raise_error(OldPlaid::BadRequest, "invalid credentials")
+    end
+
+    it "throws OldPlaid::Unauthorized on 401 response" do
+      stub = stub_request(:patch, stub_url).to_return(status: 401, body: unauth_response)
+      expect { OldPlaid::Connection.patch("testing") }.to raise_error(OldPlaid::Unauthorized, "bad access_token")
+    end
+
+    it "throws OldPlaid::RequestFailed on 402 response" do
+      stub = stub_request(:patch, stub_url).to_return(status: 402, body: req_fail_response)
+      expect { OldPlaid::Connection.patch("testing") }.to raise_error(OldPlaid::RequestFailed, "invalid credentials")
+    end
+
+    it "throws a OldPlaid::NotFound on 404 response" do
+      stub = stub_request(:patch, stub_url).to_return(status: 404, body: req_not_found)
+      expect { OldPlaid::Connection.patch("testing") }.to raise_error(OldPlaid::NotFound, "product not found")
+    end
+
+    it "throws a OldPlaid::ServerError on empty response" do
+      stub = stub_request(:patch, stub_url).to_return(status: 504, body: '')
+      expect { OldPlaid::Connection.patch("testing") }.to raise_error(OldPlaid::ServerError, '')
+    end
+  end
+
+  describe "#delete" do
+    it "sends a delete request" do
+      stub = stub_request(:delete, stub_url)
+      OldPlaid::Connection.delete("testing")
+      expect(stub).to have_requested(:delete, stub_url)
+    end
+  end
+end

data/spec/plaid/error_spec.rb

@@ -0,0 +1,10 @@
+describe OldPlaid::OldPlaidError do
+  describe "#new" do
+    it "allows code, message and resolution" do
+      error = OldPlaid::OldPlaidError.new 1, "testing", "fix it"
+      expect(error.code).to eq(1)
+      expect(error.message).to eq("testing")
+      expect(error.resolve).to eq("fix it")
+    end
+  end
+end

data/spec/plaid/models/account_spec.rb

@@ -0,0 +1,37 @@
+describe OldPlaid::Account do
+  # API: semi-private
+  describe '.new' do
+    subject { OldPlaid::Account.new(results) }
+
+    def self.with_results(_results, &examples)
+      context "with results #{_results}" do
+        let(:results) { _results }
+        instance_eval(&examples)
+      end
+    end
+
+    with_results('meta' => {'name' => 'Name'}) do it { expect(subject.name).to eql('Name') } end
+    with_results('_id' =>  'ID')   do it { expect(subject.id).to   eql('ID') }   end
+    with_results('type' => 'Type') do it { expect(subject.type).to eql('Type') } end
+    with_results('type' => 'STyp') do it { expect(subject.type).to eql('STyp') } end
+    with_results('meta' => nil)    do it { expect(subject.meta).to be_nil }      end
+    with_results('meta' => {})     do it { expect(subject.meta).to eql({}) }     end
+
+    with_results('balance' => { 'available' => 100.00 } ) do it { expect(subject.available_balance).to eql(100.00) } end
+    with_results('balance' => { 'current'   => 200.00 } ) do it { expect(subject.current_balance).to   eql(200.00) } end
+
+    with_results('institution_type' => 'Type') do it { expect(subject.institution_type).to eql('Type') } end
+
+    with_results('numbers' => nil) do
+      it { expect(subject.numbers).to eql('Upgrade user to access routing information for this account') }
+    end
+
+    with_results('numbers' => {}) do
+      it { expect(subject.numbers).to eql({}) }
+    end
+
+    with_results({}) do
+      it { expect(subject.name).to eq nil } # doesn't blow up if 'meta' is missing
+    end
+  end
+end

data/spec/plaid/models/category_spec.rb

@@ -0,0 +1,16 @@
+describe OldPlaid::Category do
+  context 'when a single category is found' do
+    let(:category) { OldPlaid.category('17001013') }
+    it { expect(category).to be_kind_of(OldPlaid::Category) }
+  end
+
+  context 'when all categories are found' do
+    let(:category) { OldPlaid.category }
+    it { expect(category).to be_kind_of(Array)}
+  end
+
+  context 'when category is not found' do
+    it { expect { OldPlaid.category('dumb_cat') }.to raise_error(OldPlaid::NotFound, 'unable to find category') }
+  end
+
+end

data/spec/plaid/models/institution_spec.rb

@@ -0,0 +1,19 @@
+describe OldPlaid::Institution do
+  context 'when a single institution is found' do
+    let(:institution) { OldPlaid.institution('5301a93ac140de84910000e0') }
+
+    it { expect(institution).to be_kind_of(OldPlaid::Institution) }
+    it { expect(institution.mfa).to be_kind_of(Array) }
+    it { expect(institution.products).to be_kind_of(Array) }
+    it { expect(institution.credentials).to be_kind_of(Hash) }
+  end
+
+  context 'when all institutions are found' do
+    let(:institution) { OldPlaid.institution }
+    it { expect(institution).to be_kind_of(Array) }
+  end
+
+  context 'when institution is not found' do
+    it { expect { OldPlaid.institution('dumb_bank') }.to raise_error(OldPlaid::NotFound, 'unable to find institution') }
+  end
+end

data/spec/plaid/models/transaction_spec.rb

@@ -0,0 +1,28 @@
+describe OldPlaid::Transaction do
+  # API: semi-private
+  describe '.new' do
+    # The reason this looks weird is because it is. This will be refactored for 2.0
+    subject { OldPlaid::Transaction.new(results) }
+
+    def self.with_results(_results, &examples)
+      context "with results #{_results}" do
+        let(:results) { _results }
+        instance_eval(&examples)
+      end
+    end
+
+    with_results('_id'      =>  'ID')       do it { expect(subject.id).to       eql('ID') }       end
+    with_results('_account' =>  'acct')     do it { expect(subject.account).to  eql('acct') }     end
+    with_results('date'     => '00/00/00')  do it { expect(subject.date).to     eql('00/00/00') } end
+    with_results('amount'   => 100.00)      do it { expect(subject.amount).to   eql(100.00) }     end
+    with_results('name'     =>  'Name')     do it { expect(subject.name).to     eql('Name') }     end
+    with_results('meta'     => {} )         do it { expect(subject.meta).to     eql({}) }         end
+    with_results('meta'     => {'location' => 'Location'}) do it { expect(subject.location).to eql('Location') } end
+    with_results('pending'  =>  true)       do it { expect(subject.pending).to  eql(true) }       end
+    with_results('score'    =>  200)        do it { expect(subject.score).to    eql(200) }        end
+    with_results('type'     =>  'Type')     do it { expect(subject.type).to     eql('Type') }     end
+
+    with_results('category'    => 'Category') do it { expect(subject.category).to    eql('Category') } end
+    with_results('category_id' => 100)        do it { expect(subject.category_id).to eql(100) } end
+  end
+end

data/spec/plaid/models/user_spec.rb

@@ -0,0 +1,172 @@
+describe OldPlaid::User do
+  let(:auth_user)    { OldPlaid.add_user('auth',    'plaid_test', 'plaid_good', 'wells') }
+  let(:connect_user) { OldPlaid.add_user('connect', 'plaid_test', 'plaid_good', 'wells') }
+  let(:info_user)    { OldPlaid.add_user('info',    'plaid_test', 'plaid_good', 'wells') }
+
+  context 'user vars' do
+    context 'valid user has accounts and accounts contain id attribute' do
+      let(:user) { OldPlaid.add_user('connect', 'plaid_test', 'plaid_good', 'wells') }
+      it { expect(user.accounts.first.id).not_to be_nil }
+    end
+
+    context 'valid user has accounts and accounts contain type attribute' do
+      let(:user) { OldPlaid.add_user('connect', 'plaid_test', 'plaid_good', 'wells') }
+      it { expect(user.accounts.first.type).to eq('depository') }
+    end
+  end
+
+  # MFA specs - after user is instantiated,
+  describe '#mfa_authentication' do
+    let(:user) { OldPlaid.add_user('connect', 'plaid_test', 'plaid_good', 'bofa') }
+    let(:new_mfa_user) { user.mfa_authentication('tomato') }
+
+    context 'enters correct credentials for MFA auth and authenticates' do
+      it { expect(new_mfa_user.accounts).not_to be_empty }
+    end
+
+    context 'enters old method of adding type strongly in each method and authenticates correctly using 2FA' do
+      let(:new_mfa_user) { user.mfa_authentication('tomato', 'bofa') }
+      it { expect(new_mfa_user.accounts).to be_truthy }
+    end
+
+    context 'has to enter another round of MFA credentials' do
+      let(:mfa_again) { user.mfa_authentication('again') }
+      it { expect(mfa_again.api_res).to eq 'Requires further authentication' }
+    end
+
+    context 'enters incorrect credentials for MFA auth' do
+      let(:mfa_user) { user.mfa_authentication('tomato') }
+      let(:mfa_bad)  { mfa_user; OldPlaid.add_user('connect', 'plaid_test', 'plaid_good', 'bofa') }
+      it { expect { mfa_bad.mfa_authentication('bad') }.to raise_error(OldPlaid::RequestFailed, 'invalid mfa') }
+    end
+
+    context 'requests list of MFA credentials' do
+      let(:new_mfa_user) { OldPlaid.add_user('auth', 'plaid_test', 'plaid_good', 'chase', nil, '{"list":true}') }
+      let(:expected_questions) do
+           {
+             "type"=>"list",
+             "mfa"=> [
+               {"mask"=>"xxx-xxx-5309", "type"=>"phone"},
+               {"mask"=>"t..t@plaid.com", "type"=>"email"}
+             ],
+             "access_token"=>"test_chase"
+           }
+      end
+      it { expect(new_mfa_user.pending_mfa_questions).to eql(expected_questions) }
+    end
+
+    context 'selects MFA method and returns successful response' do
+      let(:user) { OldPlaid.add_user('auth', 'plaid_test', 'plaid_good', 'chase', nil, '{"list":true}') }
+      let(:new_mfa_user) { user.select_mfa_method({mask: 'xxx-xxx-5309' }, 'chase') }
+      let(:expected_pending_questions) do
+        {
+          "type" => "device",
+          "mfa"  => { "message" => "Code sent to xxx-xxx-5309" },
+          "access_token" => "test_chase"
+        }
+      end
+      it { expect(new_mfa_user.pending_mfa_questions).to eql(expected_pending_questions) }
+    end
+
+    context 'selects MFA method, and delivers correct payload to authenticate user' do
+      let(:user) { OldPlaid.add_user('auth', 'plaid_test', 'plaid_good', 'chase', nil, '{"list":true}') }
+      let(:user_select_method) { user.select_mfa_method({mask:'xxx-xxx-5309'}) }
+      let(:new_mfa_user) { user_select_method.mfa_authentication(1234) }
+
+      it { expect(new_mfa_user.accounts).not_to be_empty }
+    end
+  end
+
+  context 'when authenticating' do
+    # Auth specs
+    describe '#get_auth' do
+
+      context 'has access and returns accounts' do
+        it { expect(auth_user.permissions[0]).to eq('auth') }
+      end
+
+      context 'does not have access to auth' do
+        it { expect(connect_user.permissions.include? 'auth' ).to eql(false) }
+      end
+    end
+
+    # Connect specs
+    describe '#get_connect' do
+      context 'has access and returns accounts' do
+        it { expect(connect_user.permissions[0]).to eq('connect') }
+      end
+
+      context 'does not have access to auth' do
+        it { expect(auth_user.permissions.include? 'connect' ).to eql(false) }
+      end
+    end
+
+    # Get info specs
+    describe '#get_info' do
+      context 'has access and returns user info' do
+        it { expect(info_user.permissions[0]).to eq('info') }
+      end
+
+      context 'does not have access to info' do
+        it{ expect(auth_user.permissions.include? 'info' ).to eql(false) }
+      end
+    end
+  end
+
+  describe '#get_balance' do
+    subject { user.tap(&:update_balance) }
+    let(:user) { OldPlaid.add_user('info', 'plaid_test', 'plaid_good', 'wells') }
+
+    context 'updates user accounts' do
+      it { expect(subject.accounts).not_to be_empty }
+    end
+
+    # TODO: This test needs to be rewritten better, such as using #uniq instead of this
+    context 'does not double up accounts or transactions' do
+      let(:total_duplicates) { duplicate_accounts.length + duplicate_transactions.length }
+      let(:duplicate_accounts)     { subject.accounts.select {|element| user.accounts.count(element) > 1} }
+      let(:duplicate_transactions) { subject.transactions.select {|element| user.transactions.count(element) > 1} }
+      it{ expect(total_duplicates).to eql(0) }
+    end
+  end
+
+  describe '#update_info' do
+    let(:info_user) { OldPlaid.add_user('info', 'plaid_test', 'plaid_good', 'wells') }
+    context 'updates information correctly' do
+      # TODO: This test needs to pass, currently test credentials are failing
+      pending { expect { info_user.update_info('plaid_test', 'plaid_good') }.to_not raise_error  }
+    end
+  end
+
+  describe '#delete_user' do
+    subject { info_user.tap(&:delete_user) }
+    let(:info_user) { OldPlaid.add_user('info', 'plaid_test', 'plaid_good', 'wells') }
+
+    context 'updates information correctly' do
+      it { expect { subject.get_info }.to raise_error(OldPlaid::Unauthorized, 'client_id missing') }
+    end
+  end
+
+  describe '#upgrade' do
+    subject { user.tap(&upgrade!) }
+    let(:upgrade!) { ->(x) { x.upgrade(upgrade_level) } }
+    let(:upgrade_level) { raise 'Define upgrade level' }
+
+    context 'auth upgrade is successful' do
+      let(:user)          { connect_user }
+      let(:upgrade_level) { 'auth' }
+      it { expect{ subject.get_auth }.to_not raise_error }
+    end
+
+    context 'connect upgrade is successful' do
+      let(:user)          { auth_user }
+      let(:upgrade_level) { 'connect' }
+      it { expect{ subject.get_connect }.to_not raise_error }
+    end
+  end
+
+  # This stuff needs to be tested and rewritten. Have already
+  # surfaced up a bug in it
+  pending '#populate_user'
+
+end