zoom_rb 0.11.0 → 1.1.0

data/lib/zoom/client.rb

@@ -35,14 +35,20 @@ module Zoom
 
     def oauth_request_headers
       {
-        'Authorization' => "Basic #{auth_token}"
-      }.merge(headers)
+        'Authorization' => "Basic #{auth_token}",
+        'Accept' => 'application/json',
+        'Content-Type' => 'application/x-www-form-urlencoded',
+      }
     end
 
-    def request_headers
+    def bearer_authorization_header
       {
         'Authorization' => "Bearer #{access_token}"
-      }.merge(headers)
+      }
+    end
+
+    def request_headers
+      bearer_authorization_header.merge(headers)
     end
 
     def auth_token

data/lib/zoom/clients/oauth.rb

@@ -13,7 +13,7 @@ module Zoom
       # Returns (access_token, refresh_token)
       #
       def initialize(config)
-        Zoom::Params.new(config).permit( %i[auth_token auth_code redirect_uri access_token refresh_token timeout])
+        Zoom::Params.new(config).permit( %i[auth_token auth_code redirect_uri access_token refresh_token timeout code_verifier])
         Zoom::Params.new(config).require_one_of(%i[access_token refresh_token auth_code])
         if (config.keys & [:auth_code, :redirect_uri]).any?
           Zoom::Params.new(config).require( %i[auth_code redirect_uri])
@@ -28,13 +28,19 @@ module Zoom
       end
 
       def refresh
-        response = refresh_tokens(refresh_token: @refresh_token)
+        response = refresh_tokens(grant_type: 'refresh_token', refresh_token: @refresh_token)
         set_tokens(response)
         response
       end
 
       def oauth
-        response = access_tokens(auth_code: @auth_code, redirect_uri: @redirect_uri)
+        response = access_tokens(
+          grant_type: 'authorization_code',
+          auth_code: @auth_code,
+          redirect_uri: @redirect_uri,
+          code_verifier: @code_verifier
+        )
+
         set_tokens(response)
         response
       end

data/lib/zoom/utils.rb

@@ -32,7 +32,8 @@ module Zoom
       end
 
       def extract_options!(array)
-        array.last.is_a?(::Hash) ? array.pop : {}
+        params = array.last.is_a?(::Hash) ? array.pop : {}
+        process_datetime_params!(params)
       end
 
       def validate_password(password)
@@ -40,14 +41,16 @@ module Zoom
         raise(Error , 'Invalid Password') unless password[password_regex].nil?
       end
 
-      def process_datetime_params!(params, options)
-        params = [params] unless params.is_a? Array
-        params.each do |param|
-          if options[param] && options[param].kind_of?(Time)
-            options[param] = options[param].strftime('%FT%TZ')
+      def process_datetime_params!(params)
+        params.each do |key, value|
+          case key
+          when Symbol, String
+            params[key] = value.is_a?(Time) ? value.strftime('%FT%TZ') : value
+          when Hash
+            process_datetime_params!(params[key])
           end
         end
-        options
+        params
       end
     end
   end

data/lib/zoom/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Zoom
-  VERSION = '0.11.0'
+  VERSION = '1.1.0'
 end

data/lib/zoom_rb.rb

@@ -6,6 +6,7 @@ require 'zoom/version'
 require 'zoom/constants/constants'
 require 'zoom/params'
 require 'zoom/utils'
+require 'zoom/actions'
 require 'zoom/actions/account'
 require 'zoom/actions/billing'
 require 'zoom/actions/dashboard'

data/spec/fixtures/error/admin_cannot_activated.json

@@ -0,0 +1,4 @@
+{
+  "code": 400,
+  "message": "Zoom Room and Admin users’ status cannot be activated or deactivated."
+}

data/spec/fixtures/error/group_not_exist.json

@@ -0,0 +1,4 @@
+{
+  "code": 4130,
+  "message": "A group with this 3 does not exist."
+}

data/spec/fixtures/error/not_found_administrator.json

@@ -0,0 +1,4 @@
+{
+  "code": 400,
+  "message": "Only an account administrator can change email."
+}

data/spec/fixtures/groups/create.json

@@ -0,0 +1,5 @@
+{
+  "id": "3",
+  "name": "Zoom Group Name",
+  "total_members": "1"
+}

data/spec/fixtures/token/revoke_token.json

@@ -0,0 +1,3 @@
+{
+  "status": "success"
+}

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

@@ -1,3 +1,98 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require 'spec_helper'
+
+describe Zoom::Actions::Groups do
+  let(:zc) { zoom_client }
+  let(:args) { { name: 'Zoom Group Name' } }
+  let(:response) { zc.group_create(args) }
+
+  describe '#group_create action' do
+    context 'with 201 response' do
+      before :each do
+        stub_request(
+          :post,
+          zoom_url("/groups")
+        ).to_return(
+          status: 201,
+          body: json_response('groups','create'),
+          headers: { 'Content-Type' => 'application/json' }
+        )
+      end
+
+      it 'returns a hash' do
+        expect(response).to be_kind_of(Hash)
+      end
+
+      it 'returns the set params' do
+        expect(response['name']).to eq(args[:name])
+      end
+
+      it "returns 'start_url' and 'join_url'" do
+        expect(response['name']).to_not be_nil
+      end
+    end
+
+    context 'with 409 response' do
+      before :each do
+        stub_request(
+          :post,
+          zoom_url("/groups")
+        ).to_return(status: 409,
+                    body: '{ "code": 409, "message": "Group name Zoom Group Name is already in use." }',
+                    headers: { 'Content-Type' => 'application/json' })
+      end
+
+      it 'raises an error' do
+        expect { response }.to raise_error(Zoom::Error)
+      end
+    end
+
+    context 'with 429 response' do
+      before :each do
+        stub_request(
+          :post,
+          zoom_url("/groups")
+        ).to_return(status: 429,
+                    body: '{ "code": 429, "message": "You have exceeded the daily rate limit (1) of Create a Group API request for this account. This limit resets at GMT 00:00:00." }',
+                    headers: { 'Content-Type' => 'application/json' })
+      end
+
+      it 'raises an error' do
+        expect { response }.to raise_error(Zoom::Error)
+      end
+    end
+
+    context 'with 300 response' do
+      before :each do
+        stub_request(
+          :post,
+          zoom_url("/groups")
+        ).to_return(status: 300,
+                    body: '{ "code": 300, "message": "Missing field: name." }',
+                    headers: { 'Content-Type' => 'application/json' })
+      end
+
+      it 'raises an error' do
+        expect { response }.to raise_error(Zoom::Error)
+      end
+    end
+
+    context 'with 404 response' do
+      before :each do
+        stub_request(
+          :post,
+          zoom_url("/groups")
+        ).to_return(
+          status: 404,
+          body: json_response('error', 'group_not_exist'),
+          headers: { 'Content-Type' => 'application/json' }
+        )
+      end
+
+      it 'raises an error' do
+        expect { response }.to raise_error(Zoom::Error)
+      end
+    end
+  end
+end

data/spec/lib/zoom/actions/groups/update_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Zoom::Actions::Groups do
+  let(:zc) { zoom_client }
+  let(:args) { { group_id: '555' } }
+
+  describe '#group_update' do
+    context 'with a valid response' do
+      before :each do
+        stub_request(
+          :patch,
+          zoom_url("/groups/#{args[:group_id]}")
+        ).to_return(status: 204,
+                    body: json_response('groups', 'update'),
+                    headers: { 'Content-Type' => 'application/json' })
+      end
+
+      it 'requires id param' do
+        expect { zc.group_update(filter_key(args, :group_id)) }.to raise_error(Zoom::ParameterMissing, [:group_id].to_s)
+      end
+
+      it 'returns the http status code as a number' do
+        expect(zc.group_update(args)).to eql(204)
+      end
+    end
+
+    context 'with a 404 response' do
+      before :each do
+        stub_request(
+          :patch,
+          zoom_url("/groups/#{args[:group_id]}")
+        ).to_return(status: 404,
+                    body: json_response('error', 'group_not_exist'),
+                    headers: { 'Content-Type' => 'application/json' })
+      end
+
+      it 'raises an error' do
+        expect { zc.group_update(args) }.to raise_error(Zoom::Error)
+      end
+    end
+
+    context 'with 409 response' do
+      before :each do
+        stub_request(
+          :patch,
+          zoom_url("/groups/#{args[:group_id]}")
+        ).to_return(status: 409,
+                    body: '{ "code": 409, "message": "Group name Zoom Group Name is already in use." }',
+                    headers: { 'Content-Type' => 'application/json' })
+      end
+
+      it 'raises an error' do
+        expect { zc.group_update(args) }.to raise_error(Zoom::Error)
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ require 'spec_helper'
 
 describe Zoom::Actions::Meeting do
   let(:zc) { zoom_client }
-  let(:args) { { topic: 'Zoom Meeting Topic', start_time: '2020-05-05T21:00:00Z', timezone: 'America/New_York', duration: 30, type: 2, user_id: 'r55v2FgSTVmDmVot18DX3A' } }
+  let(:args) { { topic: 'Zoom Meeting Topic', start_time: '2020-05-05T21:00:00Z', timezone: 'America/New_York', duration: 30, type: 2, user_id: 'r55v2FgSTVmDmVot18DX3A', template_id: 'template_id' } }
   let(:response) { zc.meeting_create(args) }
 
   describe '#meeting_create action' do

data/spec/lib/zoom/actions/token/access_token_spec.rb

@@ -4,23 +4,49 @@ require 'spec_helper'
 
 describe Zoom::Actions::Token do
   let(:zc) { oauth_client }
-  let(:args) { { auth_code: 'xxx', redirect_uri: 'http://localhost:3000' } }
+  let(:args) { { grant_type: 'authorization_code', auth_code: 'xxx', redirect_uri: 'http://localhost:3000', code_verifier: 'xxx' } }
+  let(:body) { { grant_type: 'authorization_code', redirect_uri: 'http://localhost:3000', code_verifier: 'xxx', code: 'xxx'  } }
 
   describe '#access_tokens action' do
+    let(:path) { '/oauth/token' }
+
+    let(:params) do
+      {
+        base_uri: 'https://zoom.us/',
+        body: URI.encode_www_form(body.to_a),
+        headers: {
+          'Accept'=>'application/json',
+          'Authorization'=>'Basic eHh4Onh4eA==',
+          'Content-Type'=>'application/x-www-form-urlencoded'
+        }
+      }
+    end
+
     before :each do
-      stub_request(
-        :post,
-        zoom_auth_url('oauth/token')
-      ).to_return(body: json_response('token', 'access_token'),
-                    headers: { 'Content-Type' => 'application/json' })
+      Zoom.configure do |config|
+        config.api_key = 'xxx'
+        config.api_secret = 'xxx'
+      end
+
+      allow(Zoom::Utils).to receive(:parse_response).and_return(code: 200)
+      allow(Zoom::Client::OAuth).to(
+        receive(:post).with(path, params)
+          .and_return(body: json_response('token', 'access_token'),
+                        headers: { 'Content-Type' => 'application/json' })
+      )
     end
 
-    it "requires an error when args missing" do
-      expect { zc.access_tokens }.to raise_error(Zoom::ParameterMissing, [:auth_code, :redirect_uri].to_s)
+    it "raises an error when args missing" do
+      expect { zc.access_tokens }.to raise_error(Zoom::ParameterMissing, [:grant_type, :code, :redirect_uri].to_s)
     end
 
     it 'returns a hash' do
       expect(zc.access_tokens(args)).to be_kind_of(Hash)
     end
+
+    it 'passes args in the body and sends x-www-form-urlencoded header' do
+      zc.access_tokens(args)
+      expect(Zoom::Client::OAuth).to have_received(:post).with(path, params)
+    end
   end
 end

data/spec/lib/zoom/actions/token/data_compliance_spec.rb

@@ -23,6 +23,11 @@ describe Zoom::Actions::Token do
 
   describe '#data_compliance action' do
     before :each do
+      Zoom.configure do |config|
+        config.api_key = 'xxx'
+        config.api_secret = 'xxx'
+      end
+
       stub_request(
         :post,
         zoom_auth_url('oauth/data/compliance')
@@ -30,7 +35,7 @@ describe Zoom::Actions::Token do
                     headers: { 'Content-Type' => 'application/json' })
     end
 
-    it "requires an error when args missing" do
+    it "raises an error when args missing" do
       expect { zc.data_compliance }.to raise_error(Zoom::ParameterMissing, [:client_id, :user_id, :account_id, :deauthorization_event_received, :compliance_completed].to_s)
     end
 

data/spec/lib/zoom/actions/token/refresh_token_spec.rb

@@ -4,23 +4,48 @@ require 'spec_helper'
 
 describe Zoom::Actions::Token do
   let(:zc) { oauth_client }
-  let(:args) { { refresh_token: 'xxx' } }
+  let(:args) { { grant_type: 'refresh_token', refresh_token: 'xxx' } }
 
   describe '#refresh_tokens action' do
+    let(:path) { '/oauth/token' }
+
+    let(:params) do
+      {
+        base_uri: 'https://zoom.us/',
+        body: URI.encode_www_form(args.to_a),
+        headers: {
+          'Accept'=>'application/json',
+          'Authorization'=>'Basic eHh4Onh4eA==',
+          'Content-Type'=>'application/x-www-form-urlencoded'
+        }
+      }
+    end
+
     before :each do
-      stub_request(
-        :post,
-        zoom_auth_url('oauth/token')
-      ).to_return(body: json_response('token', 'refresh_token'),
-                    headers: { 'Content-Type' => 'application/json' })
+      Zoom.configure do |config|
+        config.api_key = 'xxx'
+        config.api_secret = 'xxx'
+      end
+
+      allow(Zoom::Utils).to receive(:parse_response).and_return(code: 200)
+      allow(Zoom::Client::OAuth).to(
+        receive(:post).with(path, params)
+          .and_return(body: json_response('token', 'access_token'),
+                        headers: { 'Content-Type' => 'application/json' })
+      )
     end
 
-    it "requires an error when args missing" do
-      expect { zc.refresh_tokens }.to raise_error(Zoom::ParameterMissing, [:refresh_token].to_s)
+    it "raises an error when args missing" do
+      expect { zc.refresh_tokens }.to raise_error(Zoom::ParameterMissing, [:grant_type, :refresh_token].to_s)
     end
 
     it 'returns a hash' do
       expect(zc.refresh_tokens(args)).to be_kind_of(Hash)
     end
+
+    it 'passes args in the body and sends x-www-form-urlencoded header' do
+      zc.refresh_tokens(args)
+      expect(Zoom::Client::OAuth).to have_received(:post).with(path, params)
+    end
   end
 end

data/spec/lib/zoom/actions/token/revoke_token_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Zoom::Actions::Token do
+  let(:zc) { oauth_client }
+  let(:args) { { access_token: 'xxx' } }
+  let(:body) { { token: 'xxx' } }
+
+  describe '#revoke_tokens action' do
+    let(:path) { '/oauth/revoke' }
+
+    let(:params) do
+      {
+        base_uri: 'https://zoom.us/',
+        body: URI.encode_www_form(body.to_a),
+        headers: {
+          'Accept'=>'application/json',
+          'Authorization'=>'Basic eHh4Onh4eA==',
+          'Content-Type'=>'application/x-www-form-urlencoded'
+        }
+      }
+    end
+
+    before :each do
+      Zoom.configure do |config|
+        config.api_key = 'xxx'
+        config.api_secret = 'xxx'
+      end
+
+      allow(Zoom::Utils).to receive(:parse_response).and_return(code: 200)
+      allow(Zoom::Client::OAuth).to(
+        receive(:post).with(path, params)
+          .and_return(body: json_response('token', 'access_token'),
+                        headers: { 'Content-Type' => 'application/json' })
+      )
+    end
+
+    it "raises an error when args missing" do
+      expect { zc.revoke_tokens }.to raise_error(Zoom::ParameterMissing, [:token].to_s)
+    end
+
+    it 'returns a hash' do
+      expect(zc.revoke_tokens(args)).to be_kind_of(Hash)
+    end
+
+    it 'passes args in the body and sends x-www-form-urlencoded header' do
+      zc.revoke_tokens(args)
+      expect(Zoom::Client::OAuth).to have_received(:post).with(path, params)
+    end
+  end
+end

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

@@ -5,12 +5,16 @@ require 'spec_helper'
 describe Zoom::Actions::User do
   let(:zc) { zoom_client }
   let(:args) do
-    { action: 'create',
-      email: 'foo@bar.com',
-      first_name: 'Zoomie',
-      last_name: 'Userton',
-      type: 1,
-      password: 'testerino' }
+    {
+      action: 'create',
+      user_info: {
+        email: 'foo@bar.com',
+        type: 1,
+        first_name: 'Zoomie',
+        last_name: 'Userton',
+        password: 'testerino'
+      }
+    }
   end
 
   describe '#user_create' do
@@ -28,46 +32,14 @@ describe Zoom::Actions::User do
         expect { zc.user_create(filter_key(args, :action)) }.to raise_error(Zoom::ParameterMissing, [:action].to_s)
       end
 
-      it 'does not raise an error when action is create' do
-        args[:action] = 'create'
-        expect { zc.user_create(args) }.not_to raise_error
-      end
-
-      it 'does not raise an error when action is custCreate' do
-        args[:action] = 'custCreate'
-        expect { zc.user_create(args) }.not_to raise_error
-      end
-
-      it 'does not raise an error when action is autoCreate' do
-        args[:action] = 'autoCreate'
-        expect { zc.user_create(args) }.not_to raise_error
-      end
-
-      it 'does not raise an error when action is ssoCreate' do
-        args[:action] = 'ssoCreate'
-        expect { zc.user_create(args) }.not_to raise_error
-      end
-
-      it 'requires valid action' do
-        args[:action] = 'baz'
-        expect { zc.user_create(args) }.to raise_error(Zoom::ParameterValueNotPermitted, "#{:action.to_s}: #{args[:action].to_s}")
-      end
-
       it 'requires email param' do
-        expect { zc.user_create(filter_key(args, :email)) }.to raise_error(Zoom::ParameterMissing, [:email].to_s)
+        args[:user_info].delete(:email)
+        expect { zc.user_create(args) }.to raise_error(Zoom::ParameterMissing, [{user_info: [:email]}].to_s)
       end
 
       it 'requires type param' do
-        expect { zc.user_create(filter_key(args, :type)) }.to raise_error(Zoom::ParameterMissing, [:type].to_s)
-      end
-
-      it 'does not require password param when action is not autoCreate' do
-        expect { zc.user_create(filter_key(args, :password)) }.not_to raise_error
-      end
-
-      it 'requires password param when action is autoCreate' do
-        args[:action] = 'autoCreate'
-        expect { zc.user_create(filter_key(args, :password)) }.to raise_error(Zoom::ParameterMissing, [:password].to_s)
+        args[:user_info].delete(:type)
+        expect { zc.user_create(args) }.to raise_error(Zoom::ParameterMissing, [{user_info: [:type]}].to_s)
       end
 
       it 'returns a hash' do
@@ -77,10 +49,10 @@ describe Zoom::Actions::User do
       it 'returns same params' do
         res = zc.user_create(args)
 
-        expect(res['email']).to eq(args[:email])
-        expect(res['first_name']).to eq(args[:first_name])
-        expect(res['last_name']).to eq(args[:last_name])
-        expect(res['type']).to eq(args[:type])
+        expect(res['email']).to eq(args[:user_info][:email])
+        expect(res['first_name']).to eq(args[:user_info][:first_name])
+        expect(res['last_name']).to eq(args[:user_info][:last_name])
+        expect(res['type']).to eq(args[:user_info][:type])
       end
     end
 

data/spec/lib/zoom/actions/user/update_email_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Zoom::Actions::User do
+  let(:zc) { zoom_client }
+  let(:args) { { id: 'eIimBAXqSrWOcB_EOIXTog', email: 'new.email@example.com' } }
+
+  describe '#user_email_update' do
+    context 'with a valid response' do
+      before :each do
+        stub_request(
+          :patch,
+          zoom_url("/users/#{args[:id]}/email")
+        ).to_return(status: 204,
+                    body: json_response('user', 'update_email'),
+                    headers: { 'Content-Type' => 'application/json' })
+      end
+
+      it 'requires id param' do
+        expect { zc.user_email_update(filter_key(args, :id)) }.to raise_error(Zoom::ParameterMissing, [:id].to_s)
+      end
+
+      it 'returns the http status code as a number' do
+        expect(zc.user_email_update(args)).to eql(204)
+      end
+    end
+
+    context 'with a 400 response' do
+      before :each do
+        stub_request(
+            :patch,
+            zoom_url("/users/#{args[:id]}/email")
+        ).to_return(status: 400,
+                    body: json_response('error', 'not_found_administrator'),
+                    headers: { 'Content-Type' => 'application/json' })
+      end
+
+      it 'raises an error' do
+        expect { zc.user_email_update(args) }.to raise_error(Zoom::Error)
+      end
+    end
+
+    context 'with a 404 response' do
+      before :each do
+        stub_request(
+            :patch,
+            zoom_url("/users/#{args[:id]}/email")
+        ).to_return(status: 404,
+                    body: json_response('error', 'user_not_exist'),
+                    headers: { 'Content-Type' => 'application/json' })
+      end
+
+      it 'raises an error' do
+        expect { zc.user_email_update(args) }.to raise_error(Zoom::Error)
+      end
+    end
+  end
+end