authy 2.7.5 → 3.0.0

data/spec/authy/onetouch_spec.rb

@@ -1,21 +1,23 @@
 require 'spec_helper'
 
-describe Authy::OneTouch do
-  describe ".send_approval_request" do
+class Utils
+  include Authy::URL
+end
 
-    before do
-      @email = generate_email
-      @cellphone = generate_cellphone
-      @user = Authy::API.register_user(:email => @email,
-                                       :cellphone => @cellphone,
-                                       :country_code => 1)
-      expect(@user).to be_ok
-    end
+describe Authy::OneTouch do
+  let(:headers) { { "X-Authy-API-Key" => Authy.api_key, "User-Agent" => "AuthyRuby/#{Authy::VERSION} (#{RUBY_PLATFORM}, Ruby #{RUBY_VERSION})" } }
+  let(:user_id) { 81547 }
 
+  describe ".send_approval_request" do
+    let(:url) { "#{Authy.api_url}/onetouch/json/users/#{user_id}/approval_requests" }
     it 'creates a new approval_request for user' do
-      pending('The Authy account this test uses needs to have OneTouch enabled. Another option is to mock the API')
-      response = Authy::OneTouch.send_approval_request(
-        id: @user.id,
+      response_json = {
+        "approval_request" => {
+          "uuid" => "550e8400-e29b-41d4-a716-446655440000"
+        },
+        "success" => true
+      }.to_json
+      params = {
         message: 'You are moving 10 BTC from your account',
         details: {
           'Bank account' => '23527922',
@@ -25,15 +27,27 @@ describe Authy::OneTouch do
           'IP Address' => '192.168.0.3'
         },
         seconds_to_expire: 150
-      )
+      }
+
+      expect(Authy::API.http_client).to receive(:request)
+        .once
+        .with(:post, url, {
+          :body => Utils.escape_query(params),
+          :header => headers
+        })
+        .and_return(double(:status => 200, :body => response_json))
+
+      params[:id] = user_id
+      response = Authy::OneTouch.send_approval_request(params)
 
       expect(response).to be_kind_of(Authy::Response)
       expect(response).to be_ok
     end
 
     it 'requires message as mandatory' do
+      expect(Authy::API.http_client).to receive(:request).never
       response = Authy::OneTouch.send_approval_request(
-        id: @user.id,
+        id: user_id,
         details: {
           'Bank account' => '23527922',
           'Amount' => '10 BTC',
@@ -49,20 +63,39 @@ describe Authy::OneTouch do
     end
 
     it 'does not require other fields as mandatory' do
-      pending('The Authy account this test uses needs to have OneTouch enabled. Another option is to mock the API')
-      response = Authy::OneTouch.send_approval_request(
-        id: @user.id,
-        message: 'Test message'
-      )
+      response_json = {
+        "approval_request" => {
+          "uuid" => "550e8400-e29b-41d4-a716-446655440000"
+        },
+        "success" => true
+      }.to_json
+      params = {
+        message: 'You are moving 10 BTC from your account'
+      }
+
+      expect(Authy::API.http_client).to receive(:request)
+        .once
+        .with(:post, url, {
+          :body => Utils.escape_query(params),
+          :header => headers
+        })
+        .and_return(double(:status => 200, :body => response_json))
+
+      params[:id] = user_id
+      response = Authy::OneTouch.send_approval_request(params)
 
       expect(response).to be_kind_of(Authy::Response)
       expect(response).to be_ok
     end
 
     it 'checks logos format' do
-      pending('The Authy account this test uses needs to have OneTouch enabled. Another option is to mock the API')
-      response = Authy::OneTouch.send_approval_request(
-        id: @user.id,
+      response_json = {
+        "approval_request" => {
+          "uuid" => "550e8400-e29b-41d4-a716-446655440000"
+        },
+        "success" => true
+      }.to_json
+      params = {
         message: 'You are moving 10 BTC from your account',
         details: {
           'Bank account' => '23527922',
@@ -71,9 +104,19 @@ describe Authy::OneTouch do
         hidden_details: {
           'IP Address' => '192.168.0.3'
         },
-        seconds_to_expire: 150,
-        logos: [{res: 'low', url: 'http://foo.bar'}]
-      )
+        logos: [{res: 'low', url: 'http://foo.bar'}],
+        seconds_to_expire: 150
+      }
+      expect(Authy::API.http_client).to receive(:request)
+        .once
+        .with(:post, url, {
+          :body => Utils.escape_query(params),
+          :header => headers
+        })
+        .and_return(double(:status => 200, :body => response_json))
+
+      params[:id] = user_id
+      response = Authy::OneTouch.send_approval_request(params)
 
       expect(response).to be_kind_of(Authy::Response)
       expect(response).to be_ok
@@ -82,10 +125,23 @@ describe Authy::OneTouch do
 
   describe '.approval_request_status' do
     it 'returns approval request status' do
-      pending('The Authy account this test uses needs to have OneTouch enabled. Another option is to mock the API')
-      response = Authy::OneTouch.approval_request_status(
-        uuid: '550e8400-e29b-41d4-a716-446655440000'
-      )
+      uuid = '550e8400-e29b-41d4-a716-446655440000'
+      url = "#{Authy.api_url}/onetouch/json/approval_requests/#{uuid}"
+      response_json = {
+        "approval_request" => {
+          "status" => "pending"
+        },
+        "success" => true
+      }.to_json
+      expect(Authy::API.http_client).to receive(:request)
+        .once
+        .with(:get, url, {
+          :header => headers,
+          :query => {},
+          :follow_redirect => nil
+        })
+        .and_return(double(:status => 200, :body => response_json))
+      response = Authy::OneTouch.approval_request_status(uuid: uuid)
 
       expect(response).to be_kind_of(Authy::Response)
       expect(response).to be_ok

data/spec/authy/phone_verification_spec.rb

@@ -1,108 +1,239 @@
 require 'spec_helper'
 
+class Utils
+  include Authy::URL
+end
+
 describe "Authy::PhoneVerification" do
-  describe "Sending the verification code" do
+  let(:valid_phone_number) { '201-555-0123' }
+  let(:invalid_phone_number) { '123' }
+  let(:headers) { { "X-Authy-API-Key" => Authy.api_key, "User-Agent" => "AuthyRuby/#{Authy::VERSION} (#{RUBY_PLATFORM}, Ruby #{RUBY_VERSION})" } }
+  let(:start_url) { "#{Authy.api_url}/protected/json/phones/verification/start" }
+  let(:check_url) { "#{Authy.api_url}/protected/json/phones/verification/check"}
 
+  describe "Sending the verification code" do
     it "should send the code via SMS" do
-      pending("API is not returning expected response in this case. The test phone number is invalid.")
-      response = Authy::PhoneVerification.start(
+      response_json = {
+        "carrier" => "Fixed Line Operators and Other Networks",
+        "is_cellphone" => true,
+        "is_ported" => false,
+        "message" => "Text message sent to +1 201-555-0123.",
+        "seconds_to_expire" => 0,
+        "uuid" => nil,
+        "success" => true
+      }.to_json
+      params = {
         via: "sms",
         country_code: "1",
-        phone_number: "111-111-1111"
-      )
-
+        phone_number: valid_phone_number
+      }
+      expect(Authy::API.http_client).to receive(:request)
+        .once
+        .with(:post, start_url, {
+          :body => Utils.escape_query(params),
+          :header => headers
+        })
+        .and_return(double(:status => 200, :body => response_json))
+      response = Authy::PhoneVerification.start(params)
       expect(response).to be_kind_of(Authy::Response)
       expect(response).to be_ok
-      expect(response.message).to eq "Text message sent to +1 111-111-1111."
+      expect(response.message).to eq "Text message sent to +1 #{valid_phone_number}."
     end
 
-    # it "should send the code via CALL" do
-    #   response = Authy::PhoneVerification.start(
-    #     via: "call",
-    #     country_code: "1",
-    #     phone_number: "111-111-1111"
-    #   )
-
-    # response.should be_kind_of(Authy::Response)
-    #   response.success.should be_truthy
-    #   response.message.should == "Text message sent to +1 111-111-1111."
-    # end
+    it "should send the code via SMS with code length" do
+      response_json = {
+        "carrier" => "Fixed Line Operators and Other Networks",
+        "is_cellphone" => true,
+        "is_ported" => false,
+        "message" => "Text message sent to +1 201-555-0123.",
+        "seconds_to_expire" => 0,
+        "uuid" => nil,
+        "success" => true
+      }.to_json
+      params = {
+        via: "sms",
+        country_code: "1",
+        phone_number: valid_phone_number,
+        code_length: "4"
+      }
+      expect(Authy::API.http_client).to receive(:request)
+        .once
+        .with(:post, start_url, {
+          :body => Utils.escape_query(params),
+          :header => headers
+        })
+        .and_return(double(:status => 200, :body => response_json))
+      response = Authy::PhoneVerification.start(params)
+
+      expect(response).to be_kind_of(Authy::Response)
+      expect(response).to be_ok
+      expect(response.message).to eq "Text message sent to +1 #{valid_phone_number}."
+    end
   end
 
   describe "validate the fields required" do
     it "should return an error. Country code is required" do
-      response = Authy::PhoneVerification.start(
+      response_json = {
+        "error_code" => "60004",
+        "message" => "Invalid parameter: country_code - Parameter is required",
+        "errors" => {
+          "message" => "Invalid parameter: country_code - Parameter is required"
+        },
+        "success" => false
+      }.to_json
+      params = {
         via: "sms",
-        phone_number: "111-111-1111"
-      )
-
+        phone_number: valid_phone_number
+      }
+      expect(Authy::API.http_client).to receive(:request)
+        .once
+        .with(:post, start_url, {
+          :body => Utils.escape_query(params),
+          :header => headers
+        })
+        .and_return(double(:status => 400, :body => response_json))
+      response = Authy::PhoneVerification.start(params)
 
       expect(response).to_not be_ok
       expect(response.errors['message']).to match(/country_code - Parameter is required/)
     end
 
     it "should return an error. Cellphone is invalid" do
-      response = Authy::PhoneVerification.start(
+      response_json = {
+        "error_code" => "60033",
+        "message" => "Phone number is invalid",
+        "errors" => {
+          "message" => "Phone number is invalid"
+        },
+        "success" => false
+      }.to_json
+      params = {
         via: "sms",
         country_code: "1",
-        phone_number: "123"
-      )
+        phone_number: invalid_phone_number
+      }
+      expect(Authy::API.http_client).to receive(:request)
+        .once
+        .with(:post, start_url, {
+          :body => Utils.escape_query(params),
+          :header => headers
+        })
+        .and_return(double(:status => 400, :body => response_json))
+      response = Authy::PhoneVerification.start(params)
 
       expect(response).to_not be_ok
       expect(response.errors['message']).to eq('Phone number is invalid')
     end
   end
 
-  describe 'Check that a custom code request' do
-    it "should return an error if not enabled" do
-      pending("API is not returning expected response in this case. The test phone number is invalid")
-
-      response = Authy::PhoneVerification.start(
-        country_code: "1",
-        phone_number: "111-111-1111",
-        custom_code: "1234"
-      )
-      expect(response).not_to be_ok
-      expect(response.message).to eq("Phone verification couldn't be created: custom codes are not allowed.")
-    end
-  end
-
   describe "Check the verification code" do
     it "should return success true if code is correct" do
-      pending("API is not returning expected response in this case. The test phone number is invalid.")
-
-      response = Authy::PhoneVerification.check(
+      response_json = {
+        "message" => "Verification code is correct.",
+        "success" => true
+      }.to_json
+      params = {
         country_code: "1",
-        phone_number: "111-111-1111",
+        phone_number: valid_phone_number,
         verification_code: "0000"
-      )
+      }
+      expect(Authy::API.http_client).to receive(:request)
+        .once
+        .with(:get, check_url, {
+          :query => params,
+          :header => headers,
+          :follow_redirect => nil
+        })
+        .and_return(double(:status => 200, :body => response_json))
+      response = Authy::PhoneVerification.check(params)
 
       expect(response).to be_ok
       expect(response.message).to eq('Verification code is correct.')
     end
 
     it "should return an error if code is incorrect" do
-      pending("API is not returning expected response in this case. The test phone number is invalid")
-
-      response = Authy::PhoneVerification.check(
+      response_json = {
+        "error_code" => "60022",
+        "message" => "Verification code is incorrect",
+        "errors" => {
+          "message" => "Verification code is incorrect"
+        },
+        "success" => false
+      }.to_json
+      params = {
         country_code: "1",
-        phone_number: "111-111-1111",
+        phone_number: valid_phone_number,
         verification_code: "1234"
-      )
+      }
+      expect(Authy::API.http_client).to receive(:request)
+        .once
+        .with(:get, check_url, {
+          :query => params,
+          :header => headers,
+          :follow_redirect => nil
+        })
+        .and_return(double(:status => 401, :body => response_json))
+      response = Authy::PhoneVerification.check(params)
+
+      expect(response).not_to be_ok
+      expect(response.message).to eq('Verification code is incorrect')
+    end
+
+    it "should return an error if there are no active verifications" do
+      response_json = {
+        "message" => "No pending verifications for #{valid_phone_number} found.",
+        "success" => false,
+        "errors" => {
+          "message" => "No pending verifications for #{valid_phone_number} found."
+        },
+        "error_code" => "60023"
+      }.to_json
+      params = {
+        :country_code => "1",
+        :phone_number => valid_phone_number,
+        :verification_code => "1234"
+      }
+      expect(Authy::API.http_client).to receive(:request)
+        .once
+        .with(:get, check_url, {
+          :query => params,
+          :header => headers,
+          :follow_redirect => nil
+        })
+        .and_return(double(:status => 404, :body => response_json))
+
+      response = Authy::PhoneVerification.check(params)
 
       expect(response).not_to be_ok
-      expect(response.message).to eq('Verification code is incorrect.')
+      expect(response.message).to eq("No pending verifications for #{valid_phone_number} found.")
     end
   end
 
   describe 'Check the phone number' do
     it "should return an error if phone number is invalid" do
-      response = Authy::PhoneVerification.check(
+      response_json = {
+        "error_code" => "60033",
+        "message" => "Phone number is invalid",
+        "errors" => {
+          "message" => "Phone number is invalid"
+        },
+        "success" => false
+      }.to_json
+      params = {
         country_code: "1",
-        phone_number: "111-111-1111",
+        phone_number: invalid_phone_number,
         verification_code: "1234"
-      )
-
+      }
+      expect(Authy::API.http_client).to receive(:request)
+        .once
+        .with(:get, check_url, {
+          :query => params,
+          :header => headers,
+          :follow_redirect => nil
+        })
+        .and_return(double(:status => 400, :body => response_json))
+
+      response = Authy::PhoneVerification.check(params)
       expect(response).not_to be_ok
       expect(response.message).to eq('Phone number is invalid')
     end