zoom_rb 0.9.1 → 1.0.1

data/spec/lib/zoom/actions/webinar/create_spec.rb

@@ -3,51 +3,56 @@
 require 'spec_helper'
 
 RSpec.describe Zoom::Actions::Webinar do
-  let(:zc) { zoom_client }
-  let(:args) { { host_id: 'test_user_id' } }
-
-  describe '#webinar_create' do
-    context 'with a valid response' do
-      before :each do
-        stub_request(
-          :post,
-          zoom_url("/users/#{args[:host_id]}/webinars")
-        ).to_return(body: json_response('webinar', 'create'),
-                    headers: { 'Content-Type' => 'application/json' })
-      end
-
-      it "requires a 'host_id' argument" do
-        expect { zc.webinar_create(filter_key(args, :host_id)) }.to raise_error(Zoom::ParameterMissing, [:host_id].to_s)
-      end
-
-      it 'returns a hash' do
-        expect(zc.webinar_create(args)).to be_kind_of(Hash)
-      end
-
-      it 'returns the setted params' do
-        res = zc.webinar_create(args)
-        expect(res['host_id']).to eq(args[:host_id])
-      end
-
-      it "returns 'start_url' and 'join_url'" do
-        res = zc.webinar_create(args)
-
-        expect(res['start_url']).to_not be_nil
-        expect(res['join_url']).to_not be_nil
-      end
-    end
-
-    context 'with a 4xx response' do
-      before :each do
-        stub_request(
-          :post,
-          zoom_url("/users/#{args[:host_id]}/webinars")
-        ).to_return(body: json_response('error', 'validation'),
-                    headers: { 'Content-Type' => 'application/json' })
-      end
 
-      it 'raises Zoom::Error exception' do
-        expect { zc.webinar_create(args) }.to raise_error(Zoom::Error)
+  [:jwt_client, :oauth_client].each do |client|
+    describe "#{client}" do
+      let(:zc) { send(client) }
+      let(:args) { { host_id: 'test_user_id' } }
+
+      describe '#webinar_create' do
+        context 'with a valid response' do
+          before :each do
+            stub_request(
+              :post,
+              zoom_url("/users/#{args[:host_id]}/webinars")
+            ).to_return(body: json_response('webinar', 'create'),
+                        headers: { 'Content-Type' => 'application/json' })
+          end
+
+          it "requires a 'host_id' argument" do
+            expect { zc.webinar_create(filter_key(args, :host_id)) }.to raise_error(Zoom::ParameterMissing, [:host_id].to_s)
+          end
+
+          it 'returns a hash' do
+            expect(zc.webinar_create(args)).to be_kind_of(Hash)
+          end
+
+          it 'returns the setted params' do
+            res = zc.webinar_create(args)
+            expect(res['host_id']).to eq(args[:host_id])
+          end
+
+          it "returns 'start_url' and 'join_url'" do
+            res = zc.webinar_create(args)
+
+            expect(res['start_url']).to_not be_nil
+            expect(res['join_url']).to_not be_nil
+          end
+        end
+
+        context 'with a 4xx response' do
+          before :each do
+            stub_request(
+              :post,
+              zoom_url("/users/#{args[:host_id]}/webinars")
+            ).to_return(body: json_response('error', 'validation'),
+                        headers: { 'Content-Type' => 'application/json' })
+          end
+
+          it 'raises Zoom::Error exception' do
+            expect { zc.webinar_create(args) }.to raise_error(Zoom::Error)
+          end
+        end
       end
     end
   end

data/spec/lib/zoom/actions/webinar/panelist_list_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Zoom::Actions::Webinar do
+  let(:zc) { zoom_client }
+  let(:args) { { webinar_id: '123456789' } }
+
+  describe '#webinar_panelist_list' do
+    context 'with a valid response' do
+      before :each do
+        stub_request(
+          :get,
+          zoom_url("/webinars/#{args[:webinar_id]}/panelists")
+        ).to_return(status: 200,
+                    body: json_response('webinar', 'panelist_list'),
+                    headers: { 'Content-Type' => 'application/json' })
+      end
+
+      it "requires a 'id' argument" do
+        expect { zc.webinar_panelist_list(filter_key(args, :webinar_id)) }.to raise_error(Zoom::ParameterMissing, [:webinar_id].to_s)
+      end
+
+      it 'returns a list of panelists as an array' do
+        expect(zc.webinar_panelist_list(args)['panelists']).to be_kind_of(Array)
+      end
+    end
+
+    context 'with a 4xx response' do
+      before :each do
+        stub_request(
+          :get,
+          zoom_url("/webinars/#{args[:webinar_id]}/panelists")
+        ).to_return(status: 404,
+                    body: json_response('error', 'validation'),
+                    headers: { 'Content-Type' => 'application/json' })
+      end
+
+      it 'raises Zoom::Error exception' do
+        expect { zc.webinar_panelist_list(args) }.to raise_error(Zoom::Error)
+      end
+    end
+  end
+end

data/spec/lib/zoom/actions/webinar/poll_get_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Zoom::Actions::Webinar do
+  let(:zc) { zoom_client }
+  let(:args) { { webinar_id: 'foo', poll_id: 'bar' } }
+
+  describe '#webinar_poll_get' do
+    context 'with a valid response' do
+      before :each do
+        stub_request(
+          :get,
+          zoom_url("/webinars/#{args[:webinar_id]}/polls/#{args[:poll_id]}")
+        ).to_return(status: :ok,
+                    body: json_response('webinar', 'poll_get'),
+                    headers: { 'Content-Type' => 'application/json' })
+      end
+
+      it "requires a 'webinar_id' argument" do
+        expect { zc.webinar_poll_get(filter_key(args, :webinar_id)) }.to raise_error(Zoom::ParameterMissing, [:webinar_id].to_s)
+      end
+
+      it "requires a 'poll_id' argument" do
+        expect { zc.webinar_poll_get(filter_key(args, :poll_id)) }.to raise_error(Zoom::ParameterMissing, [:poll_id].to_s)
+      end
+
+      it 'returns a hash' do
+        expect(zc.webinar_poll_get(args)).to be_a(Hash)
+      end
+    end
+
+    context 'with a 4xx response' do
+      before :each do
+        stub_request(
+          :get,
+          zoom_url("/webinars/#{args[:webinar_id]}/polls/#{args[:poll_id]}")
+        ).to_return(body: json_response('error', 'validation'),
+                    headers: { 'Content-Type' => 'application/json' })
+      end
+
+      it 'raises Zoom::Error exception' do
+        expect { zc.webinar_poll_get(args) }.to raise_error(Zoom::Error)
+      end
+    end
+  end
+end

data/spec/lib/zoom/actions/webinar/polls_list_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Zoom::Actions::Webinar do
+  let(:zc) { zoom_client }
+  let(:args) { { webinar_id: '123456789' } }
+
+  describe '#webinar_polls_list' do
+    context 'with a valid response' do
+      before :each do
+        stub_request(
+          :get,
+          zoom_url("/webinars/#{args[:webinar_id]}/polls")
+        ).to_return(status: :ok,
+                    body: json_response('webinar', 'polls_list'),
+                    headers: { 'Content-Type' => 'application/json' })
+      end
+
+      it "requires a 'webinar_id' argument" do
+        expect { zc.webinar_polls_list(filter_key(args, :webinar_id)) }.to raise_error(Zoom::ParameterMissing, [:webinar_id].to_s)
+      end
+
+      it 'returns the http status code as a number' do
+        expect(zc.webinar_polls_list(args)['polls']).to be_an(Array)
+      end
+    end
+
+    context 'with a 4xx response' do
+      before :each do
+        stub_request(
+          :get,
+          zoom_url("/webinars/#{args[:webinar_id]}/polls")
+        ).to_return(status: 404,
+                    body: json_response('error', 'not_found'),
+                    headers: { 'Content-Type' => 'application/json' })
+      end
+
+      it 'raises an error' do
+        expect { zc.webinar_polls_list(args) }.to raise_error(Zoom::Error)
+      end
+    end
+  end
+end

data/spec/lib/zoom/actions/webinar/registrants/get_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Zoom::Actions::Webinar do
+  let(:zc) { zoom_client }
+  let(:args) { { webinar_id: 'webinar_id', id: 'registrant_id' } }
+
+  describe '#webinar_registrant_get' do
+    context 'with a valid response' do
+      before :each do
+        stub_request(
+          :get,
+          zoom_url("/webinars/#{args[:webinar_id]}/registrants/#{args[:id]}")
+        ).to_return(body: json_response('webinar', 'registrant', 'get'),
+                    headers: { 'Content-Type' => 'application/json' })
+      end
+
+      it "requires a 'webinar_id' argument" do
+        expect { zc.webinar_registrant_get(filter_key(args, :webinar_id)) }.to raise_error(Zoom::ParameterMissing, [:webinar_id].to_s)
+      end
+      it "requires a 'id' argument" do
+        expect { zc.webinar_registrant_get(filter_key(args, :id)) }.to raise_error(Zoom::ParameterMissing, [:id].to_s)
+      end
+      it "allows occurrence_id" do
+        expect { zc.webinar_registrant_get(args.merge(:occurrence_id => '5')) }.not_to raise_error
+      end
+
+      it 'returns an Hash' do
+        expect(zc.webinar_registrant_get(args)).to be_kind_of(Hash)
+      end
+    end
+
+    context 'with a 4xx response' do
+      before :each do
+        stub_request(
+          :get,
+          zoom_url("/webinars/#{args[:webinar_id]}/registrants/#{args[:id]}")
+        ).to_return(status: 404,
+                    body: json_response('error', 'validation'),
+                    headers: { 'Content-Type' => 'application/json' })
+      end
+
+      it 'raises Zoom::Error exception' do
+        expect { zc.webinar_registrant_get(args) }.to raise_error(Zoom::Error)
+      end
+    end
+  end
+end

data/spec/lib/zoom/actions_spec.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Zoom::Actions do
+  let(:client) { Zoom::Client::OAuth.new(access_token: 'xxx', timeout: 15) }
+  let(:path) { '/:id/foo/:bar' }
+  let(:path_keys) { [:id, :bar] }
+  let(:params) { { id: 100, bar: 'baz' } }
+  let(:oauth) { false }
+  let(:parsed_path) { '/100/foo/baz' }
+
+  describe 'self.extract_path_keys' do
+    subject { described_class.extract_path_keys(path) }
+    
+    it { is_expected.to match_array(path_keys) }
+  end
+
+  describe 'self.parse_path' do
+    subject { described_class.parse_path(path, path_keys, params) }
+
+    it { is_expected.to eq(parsed_path) }
+  end
+
+  describe 'self.make_request' do
+    subject { described_class.make_request(client, method, parsed_path, params, request_options) }
+
+    let(:request_options) { Zoom::Actions.determine_request_options(client, oauth) }
+
+    context 'when get' do
+      let(:method) { :get }
+
+      it 'calls get method on client with get request_options' do
+        request_options[:query] = params
+        expect(client.class).to receive(method).with(parsed_path, **request_options)
+        subject
+      end
+    end
+
+    context 'when post' do
+      let(:method) { :post }
+
+      it 'calls post method on client with post request_options' do
+        request_options[:body] = params.to_json
+        expect(client.class).to receive(method).with(parsed_path, **request_options)
+        subject
+      end
+    end
+
+    context 'when put' do
+      let(:method) { :put }
+
+      it 'calls put method on client with put request_options' do
+        request_options[:body] = params.to_json
+        expect(client.class).to receive(method).with(parsed_path, **request_options)
+        subject
+      end
+    end
+
+    context 'when patch' do
+      let(:method) { :patch }
+
+      it 'calls patch method on client with patch request_options' do
+        request_options[:body] = params.to_json
+        expect(client.class).to receive(method).with(parsed_path, **request_options)
+        subject
+      end
+    end
+
+    context 'when delete' do
+      let(:method) { :delete }
+
+      it 'calls delete method on client with delete request_options' do
+        expect(client.class).to receive(method).with(parsed_path, **request_options)
+        subject
+      end
+    end
+
+    context 'when oauth' do
+      let(:method) { :get }
+      let(:oauth) { true }
+
+      it 'passes oauth request options' do
+        request_options[:query] = params
+        expect(request_options[:headers]).to eq(client.oauth_request_headers)
+        expect(request_options[:base_uri]).to eq('https://zoom.us/')
+        expect(client.class).to receive(method).with(parsed_path, **request_options)
+        subject
+      end
+    end
+
+    context 'when not oauth' do
+      let(:method) { :get }
+      let(:oauth) { false }
+
+      it 'passes standard request options' do
+        request_options[:query] = params
+        expect(request_options[:headers]).to eq(client.request_headers)
+        expect(request_options[:base_uri]).to be_nil
+        expect(client.class).to receive(method).with(parsed_path, **request_options)
+        subject
+      end
+    end
+  end
+end

data/spec/lib/zoom/client_spec.rb

@@ -2,11 +2,12 @@
 
 require 'spec_helper'
 
-xdescribe Zoom::Client do
+describe Zoom::Client do
 
-  xdescribe 'default attributes' do
+  describe 'default attributes' do
     it 'must include httparty methods' do
       expect(Zoom::Client).to include(HTTParty)
+      expect(Zoom::Client::JWT).to include(HTTParty)
     end
 
     it 'must have the base url set to Zoom API endpoint' do
@@ -19,7 +20,8 @@ xdescribe Zoom::Client do
         config.api_secret = 'xxx'
       end
       Zoom.new
-      expect(Zoom::Client.default_options[:timeout]).to eq(15)
+      expect(Zoom::Client::JWT.default_options[:timeout]).to eq(15)
+      Zoom.configuration = nil
     end
 
     it 'must get the timeout from the configuration' do
@@ -29,17 +31,93 @@ xdescribe Zoom::Client do
         config.timeout = 20
       end
       Zoom.new
-      expect(Zoom::Client.default_options[:timeout]).to eq(20)
+      expect(Zoom::Client::JWT.default_options[:timeout]).to eq(20)
+      Zoom.configuration = nil
     end
   end
 
-  xdescribe 'constructor' do
+  describe 'JWT client' do
+    let(:client) {
+      Zoom::Client::JWT.new(api_key: 'xxx', api_secret: 'xxx', timeout: 15)
+    }
     it 'requires api_key and api_secret for a new instance' do
-      expect { Zoom::Client.new(api_key: 'xxx') }.to raise_error(ArgumentError)
+      expect { Zoom::Client::JWT.new(api_key: 'xxx') }.to raise_error(Zoom::ParameterMissing)
+      expect { Zoom::Client::JWT.new(api_key: 'xxx', api_secret: 'xxx') }.not_to raise_error
     end
 
     it 'creates instance of Zoom::Client if api_key and api_secret is provided' do
-      expect(Zoom::Client.new(api_key: 'xxx', api_secret: 'xxx', timeout: 15)).to be_an_instance_of(Zoom::Client)
+      expect(client).to be_kind_of(Zoom::Client)
+    end
+
+    it 'has the bearer token in the auth header' do
+      fake_token = 'NotTheRealToken'
+      allow(client).to receive(:access_token) {fake_token}
+      expect(client.request_headers['Authorization']).to eq("Bearer #{fake_token}")
+    end
+
+  end
+
+  describe 'OAuth client' do
+    let(:access_token) {'xxx'}
+    let(:refresh_token) {'xxx'}
+    let(:auth_token) {'xxx'}
+    let(:client) {
+      Zoom::Client::OAuth.new(access_token: access_token, timeout: 30)
+    }
+    it 'raises an error if there is no token' do
+      expect { Zoom::Client::OAuth.new(timeout: 30) }.to raise_error(Zoom::ParameterMissing)
+    end
+
+    it 'raises an error if there is no complete auth token, auth code and redirect_uri' do
+      expect { Zoom::Client::OAuth.new(auth_token: 'xxx', auth_code: 'xxx', redirect_uri: 'xxx') }.not_to raise_error
+    end
+
+    it 'requires atleast an access token' do
+      expect { Zoom::Client::OAuth.new(access_token: access_token) }.not_to raise_error
+    end
+
+    it 'requires atleast a refresh token' do
+      expect { Zoom::Client::OAuth.new(refresh_token: refresh_token) }.not_to raise_error
+    end
+
+    it 'creates instance of Zoom::Client if api_key and api_secret is provided' do
+      expect(client).to be_kind_of(Zoom::Client)
+    end
+
+    it 'has the bearer token in the auth header' do
+      expect(client.request_headers['Authorization']).to eq("Bearer #{access_token}")
+    end
+
+    describe 'set_tokens' do
+      let(:zc) { oauth_client }
+      let(:args) { { auth_code: 'xxx', redirect_uri: 'http://localhost:3000' } }
+
+      before :each do
+        Zoom.configure do |config|
+          config.api_key = 'xxx'
+          config.api_secret = 'xxx'
+          config.timeout = 20
+        end
+
+        stub_request(
+          :post,
+          zoom_auth_url('oauth/token')
+        ).to_return(body: json_response('token', 'access_token'),
+                    headers: { 'Content-Type' => 'application/json' })
+      end
+
+      it 'sets the refresh_token, access_token, expires_in and expires_at' do
+        expected_values = JSON.parse(json_response('token', 'access_token'))
+        zc.auth
+        expect(zc.access_token).to eq(expected_values['access_token'])
+        expect(zc.refresh_token).to eq(expected_values['refresh_token'])
+        expect(zc.expires_in).to eq(expected_values['expires_in'])
+        expect(zc.expires_at).to eq((Time.now + expected_values['expires_in']).to_i)
+      end
+
+      it 'has the basic auth authorization header' do
+        expect(zc.oauth_request_headers['Authorization']).to eq("Basic eHh4Onh4eA==")
+      end
     end
   end
 end

data/spec/lib/zoom/params_spec.rb

@@ -8,7 +8,7 @@ RSpec.describe Zoom::Params do
     let(:params) { Zoom::Params.new(foo: :bar, baz: :bang) }
 
     it 'does not raise an error when required keys are present' do
-      expect { params.require(:foo) }.not_to raise_error(Zoom::ParameterMissing)
+      expect { params.require(:foo) }.not_to raise_error
     end
 
     it 'does raise an error when required keys are missing' do
@@ -20,15 +20,35 @@ RSpec.describe Zoom::Params do
     end
   end
 
+  describe '#require_one_of' do
+    let(:params) { Zoom::Params.new(foo: :bar, baz: :bang) }
+
+    it 'does raise an error when required keys are missing' do
+      expect { params.require_one_of(:bar) }.to raise_error(Zoom::ParameterMissing, [:bar].to_s)
+    end
+
+    it 'does raise an error when there is a missing required keys out of many' do
+      expect { params.require_one_of(:bar, :fooey, :fooa) }.to raise_error(Zoom::ParameterMissing, "You are missing atleast one of #{[:bar, :fooey, :fooa].to_s}")
+    end
+
+    it 'does not raise an error when one of the required keys are missing' do
+      expect { params.require_one_of(:foo) }.not_to raise_error
+    end
+
+    it 'does not raise an error when one of the required keys are missing' do
+      expect { params.require_one_of(:foo, :bebop) }.not_to raise_error
+    end
+  end
+
   describe '#permit' do
     let(:params) { Zoom::Params.new(foo: true, bar: :baz ) }
 
     it 'does not raise an error when permitted keys are present' do
-      expect { params.require(:foo).permit(:bar) }.not_to raise_error(Zoom::ParameterNotPermitted)
+      expect { params.require(:foo).permit(:bar) }.not_to raise_error
     end
 
     it 'does not raise an error when permitted keys are not present' do
-      expect { params.require(:foo).permit(:bar, :bang) }.not_to raise_error(Zoom::ParameterNotPermitted)
+      expect { params.require(:foo).permit(:bar, :bang) }.not_to raise_error
     end
 
     context 'raises an error' do

data/spec/lib/zoom/utils_spec.rb

@@ -2,21 +2,26 @@
 
 require 'spec_helper'
 
-xdescribe Zoom::Utils do
+describe Zoom::Utils do
 
   before(:all) do
     class Utils < Zoom::Utils; end
   end
 
-  xdescribe '#argument_error' do
+  describe '#argument_error' do
     it 'raises ArgumentError' do
       expect(Utils.argument_error('foo')).to be_instance_of(ArgumentError)
     end
   end
 
-  xdescribe '#raise_if_error!' do
-    it 'raises Zoom::Error if error is present' do
-      response = { 'error' => { 'message' => 'lol error' } }
+  describe '#raise_if_error!' do
+    it 'raises Zoom::AuthenticationError if error is present and code = 124' do
+      response = { 'code' => 124, 'message' => 'Invalid access token.' }
+      expect { Utils.raise_if_error!(response) }.to raise_error(Zoom::AuthenticationError)
+    end
+
+    it 'raises Zoom::Error if error is present and code >= 300' do
+      response = { 'code' => 400, 'message' => 'lol error' }
       expect { Utils.raise_if_error!(response) }.to raise_error(Zoom::Error)
     end
 
@@ -26,31 +31,21 @@ xdescribe Zoom::Utils do
     end
   end
 
-  xdescribe '#require_params' do
-    it 'raises ArgumentError if the param is not present' do
-      expect { Utils.require_params(:foo, { bar: 'bar' }) }.to raise_error(ArgumentError)
-    end
-
-    it 'does not raise ArgumentError if the param is present' do
-      expect { Utils.require_params(:foo, { foo: 'foo' }) }.to_not raise_error
-    end
-  end
-
-  xdescribe '#extract_options!' do
+  describe '#extract_options!' do
     it 'converts array to hash options' do
       args = [{ foo: 'foo' }, { bar: 'bar' }, { zemba: 'zemba' }]
       expect(Utils.extract_options!(args)).to be_kind_of(Hash)
     end
   end
 
-  xdescribe '#process_datetime_params' do
+  describe '#process_datetime_params' do
     it 'converts the Time objects to formatted strings' do
       args = {
         foo: 'foo',
         bar: Time.utc(2000, 'jan', 1, 20, 15, 1)
       }
       expect(
-        Utils.process_datetime_params!(:bar, args)
+        Utils.process_datetime_params!(args)
       ).to eq({ foo: 'foo',
                 bar: '2000-01-01T20:15:01Z' })
     end

data/spec/spec_helper.rb

@@ -5,7 +5,7 @@ SimpleCov.start
 
 require 'rubygems'
 require 'bundler/setup'
-require 'zoom'
+require 'zoom_rb'
 require 'webmock/rspec'
 
 RSpec.configure do |config|
@@ -20,14 +20,35 @@ def json_response(*path, endpoint)
   open(fixture(path, endpoint + '.json')).read
 end
 
+def request_headers
+  {
+    'Accept' => 'application/json',
+    'Content-Type' => 'application/json',
+    'Authorization' => /Bearer .+/
+  }
+end
+
 def zoom_url(url)
   /https:\/\/api.zoom.us\/v2#{url}.*/
 end
 
-def zoom_client
+#OAuth endpoints have a different base_uri
+def zoom_auth_url(url)
+  /https:\/\/zoom.us\/#{url}.*/
+end
+
+def jwt_client
   Zoom.new
 end
 
+def oauth_client
+  Zoom::Client::OAuth.new(auth_token: 'xxx', auth_code: 'xxx', redirect_uri: 'xxx', timeout: 15)
+end
+
+def zoom_client
+  jwt_client
+end
+
 def filter_key(hash, key)
   copy = hash.dup
   copy.delete(key)

data/zoom_rb.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'json', '>= 1.8'
   gem.add_dependency 'jwt'
 
-  gem.add_development_dependency 'pry', '~> 0'
+  gem.add_development_dependency 'pry-byebug'
   gem.add_development_dependency 'hint-rubocop_style', '~> 0'
   gem.add_development_dependency 'rspec', '~> 3.8'
   gem.add_development_dependency 'rspec_junit_formatter', '~> 0.4.1'