kirimi 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0bc013f5f011e16f83060dc902e32b6cf6c45312c2d6c443cb882503babed732
-  data.tar.gz: '082c9dcd26bee5df651c865dc77c93222c49f8fa70e68d4e5970ef9013efad17'
+  metadata.gz: 6f1ffed06942da09afddf27319d189d03aa8230e6f711b7cd8b5e7fabc553507
+  data.tar.gz: 477551b4134d8fda91be2ac6e7428ec76ccc19776135f8c44d653db3c9ec40c2
 SHA512:
-  metadata.gz: 487b38bee90b1463c0550efdb36a7646e0bdfd50ec2f0e598407bf4aacf3b0a3a770f0c0fead719b0fb98ad68debfa54e8b26574a538c5b76b4ff1cefa94d0a4
-  data.tar.gz: cc5f8545838710df3641cf0207aa2dc9d168c906f76a2edc1d288942f4ce05677ed9ffa50e7c2c45c5b6128dcafec5950cf0198bc821cf989fcd66cf5d7fafe2
+  metadata.gz: ab06658c77c3c00460c80750702841282caea944b4c2bdfdada7d8720a8ccfe2c7422a272b7e6350dd600a75e8401513f85319b858c36afa8d0807a6386f44fa
+  data.tar.gz: d8f1c9079ae6457760ccddedb4e84213bad075219fd55f006803e043292a646734d0c9117a076fe45c6af443315f6c8d7b40d7fff1be7324ac508d765deb29ae

data/kirimi.gemspec

@@ -20,10 +20,12 @@ Gem::Specification.new do |spec|
   spec.metadata['changelog_uri']   = "#{spec.homepage}/blob/main/CHANGELOG.md"
 
   spec.files         = Dir.glob(%w[lib/**/* LICENSE README.md CHANGELOG.md kirimi.gemspec])
-  spec.test_files    = Dir.glob('test/**/*_test.rb')
+  spec.test_files    = Dir.glob('spec/**/*_spec.rb')
   spec.require_paths = ['lib']
 
   # No runtime dependencies — uses only Ruby stdlib (net/http, json, securerandom)
 
   spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.12'
+  spec.add_development_dependency 'webmock', '~> 3.19'
 end

data/lib/kirimi/client.rb

@@ -3,6 +3,7 @@
 require 'net/http'
 require 'json'
 require 'uri'
+require 'securerandom'
 
 module Kirimi
   class Client
@@ -18,43 +19,122 @@ module Kirimi
 
     # --- WhatsApp Unofficial ---
 
-    def send_message(device_id:, phone:, message:, media_url: nil)
-      body = { device_id: device_id, phone: phone, message: message }
-      body[:media_url] = media_url if media_url
+    def send_message(device_id:, receiver:, message:, media_url: nil, file_name: nil,
+                     enable_typing_effect: nil, typing_speed_ms: nil, quoted_message_id: nil)
+      body = { device_id: device_id, receiver: receiver, message: message }
+      body[:media_url]           = media_url           if media_url
+      body[:fileName]            = file_name           if file_name
+      body[:enableTypingEffect]  = enable_typing_effect unless enable_typing_effect.nil?
+      body[:typingSpeedMs]       = typing_speed_ms     if typing_speed_ms
+      body[:quotedMessageId]     = quoted_message_id   if quoted_message_id
       post('/v1/send-message', body)
     end
 
-    def send_message_file(device_id:, phone:, file:, file_name:, message: nil)
+    def send_message_file(device_id:, receiver:, file:, file_name: nil, message: nil, caption: nil,
+                          quoted_message_id: nil)
       file_io = file.is_a?(String) ? File.open(file, 'rb') : file
       fields = {
         'user_code' => @user_code,
         'secret'    => @secret,
         'device_id' => device_id,
-        'phone'     => phone,
-        'fileName'  => file_name
+        'receiver'  => receiver
       }
-      fields['message'] = message if message
-      post_multipart('/v1/send-message-file', fields, file_io, file_name)
+      fields['fileName']        = file_name        if file_name
+      fields['message']         = message          if message
+      fields['caption']         = caption          if caption
+      fields['quotedMessageId'] = quoted_message_id if quoted_message_id
+      post_multipart('/v1/send-message-file', fields, file_io, file_name || 'file')
     ensure
       file_io&.close if file.is_a?(String)
     end
 
-    def send_message_fast(device_id:, phone:, message:, media_url: nil)
-      body = { device_id: device_id, phone: phone, message: message }
-      body[:media_url] = media_url if media_url
+    def send_message_fast(device_id:, receiver:, message:, media_url: nil, file_name: nil,
+                          quoted_message_id: nil)
+      body = { device_id: device_id, receiver: receiver, message: message }
+      body[:media_url]       = media_url         if media_url
+      body[:fileName]        = file_name         if file_name
+      body[:quotedMessageId] = quoted_message_id if quoted_message_id
       post('/v1/send-message-fast', body)
     end
 
-    # --- WABA ---
+    # --- Broadcast ---
+
+    def broadcast_message(device_id:, label:, numbers:, message:, delay: nil, delay_min: nil,
+                          delay_max: nil, media_url: nil, file_name: nil, started_at: nil,
+                          enable_typing_effect: nil, typing_speed_ms: nil)
+      body = {
+        device_id: device_id,
+        label:     label,
+        numbers:   Array(numbers),
+        message:   message
+      }
+      body[:delay]              = delay           if delay
+      body[:delayMin]           = delay_min       if delay_min
+      body[:delayMax]           = delay_max       if delay_max
+      body[:media_url]          = media_url       if media_url
+      body[:fileName]           = file_name       if file_name
+      body[:started_at]         = started_at      if started_at
+      body[:enableTypingEffect] = enable_typing_effect unless enable_typing_effect.nil?
+      body[:typingSpeedMs]      = typing_speed_ms if typing_speed_ms
+      post('/v1/broadcast-message', body)
+    end
+
+    # --- WABA (Cloud API) ---
+
+    def send_waba_message(waba_id:, to:, template_name:, variables: nil, header: nil, buttons: nil)
+      body = { waba_id: waba_id, to: to, template_name: template_name }
+      body[:variables] = variables if variables
+      body[:header]    = header    if header
+      body[:buttons]   = buttons   if buttons
+      post('/v1/waba/send-message', body)
+    end
+
+    def waba_reply(waba_id:, to:, message:)
+      post('/v1/waba/messages/reply', { waba_id: waba_id, to: to, message: message })
+    end
+
+    def waba_conversations(limit: nil, page: nil)
+      body = {}
+      body[:limit] = limit if limit
+      body[:page]  = page  if page
+      post('/v1/waba/conversations', body)
+    end
+
+    def waba_templates_sync(waba_id:)
+      post('/v1/waba/templates/sync', { waba_id: waba_id })
+    end
 
-    def send_waba_message(device_id:, phone:, message:)
-      post('/v1/waba/send-message', { device_id: device_id, phone: phone, message: message })
+    def waba_send_otp(waba_id:, to:, template_name:)
+      post('/v1/waba/send-otp', { waba_id: waba_id, to: to, template_name: template_name })
+    end
+
+    def waba_verify_otp(waba_id:, to:, otp_code:)
+      post('/v1/waba/verify-otp', { waba_id: waba_id, to: to, otp_code: otp_code })
     end
 
     # --- Devices ---
 
-    def list_devices
-      post('/v1/list-devices', {})
+    def create_device(package_id:, voucher_code: nil)
+      body = { package_id: package_id }
+      body[:voucher_code] = voucher_code if voucher_code
+      post('/v1/create-device', body)
+    end
+
+    def connect_device(device_id:)
+      post('/v1/connect-device', { device_id: device_id })
+    end
+
+    def renew_device(device_id:, package_id:, voucher_code: nil)
+      body = { device_id: device_id, package_id: package_id }
+      body[:voucher_code] = voucher_code if voucher_code
+      post('/v1/renew-device', body)
+    end
+
+    def list_devices(page: nil, limit: nil)
+      body = {}
+      body[:page]  = page  if page
+      body[:limit] = limit if limit
+      post('/v1/list-devices', body)
     end
 
     def device_status(device_id:)
@@ -73,20 +153,29 @@ module Kirimi
 
     # --- Contacts ---
 
-    def save_contact(phone:, name: nil, email: nil)
-      body = { phone: phone }
-      body[:name]  = name  if name
-      body[:email] = email if email
+    def save_contact(nama:, nomor:, device_id: nil)
+      body = { nama: nama, nomor: nomor }
+      body[:device_id] = device_id if device_id
       post('/v1/save-contact', body)
     end
 
-    # --- OTP ---
+    def save_contacts_bulk(contacts:, device_id: nil)
+      body = { contacts: contacts }
+      body[:device_id] = device_id if device_id
+      post('/v1/save-contacts-bulk', body)
+    end
+
+    # --- OTP (V1) ---
 
-    def generate_otp(device_id:, phone:, otp_length: nil, otp_type: nil, custom_otp_message: nil)
+    def generate_otp(device_id:, phone:, otp_length: nil, otp_type: nil, custom_otp_text: nil,
+                     custom_otp_message: nil, enable_typing_effect: nil, typing_speed_ms: nil)
       body = { device_id: device_id, phone: phone }
-      body[:otp_length]       = otp_length        if otp_length
-      body[:otp_type]         = otp_type           if otp_type
-      body[:customOtpMessage] = custom_otp_message if custom_otp_message
+      body[:otp_length]         = otp_length         if otp_length
+      body[:otp_type]           = otp_type           if otp_type
+      body[:customOtpText]      = custom_otp_text    if custom_otp_text
+      body[:customOtpMessage]   = custom_otp_message if custom_otp_message
+      body[:enableTypingEffect] = enable_typing_effect unless enable_typing_effect.nil?
+      body[:typingSpeedMs]      = typing_speed_ms    if typing_speed_ms
       post('/v1/generate-otp', body)
     end
 
@@ -94,13 +183,16 @@ module Kirimi
       post('/v1/validate-otp', { device_id: device_id, phone: phone, otp: otp })
     end
 
-    # --- OTP V2 ---
+    # --- OTP (V2) ---
 
-    def send_otp_v2(phone:, device_id:, method: nil, app_name: nil, template_code: nil, custom_message: nil)
-      body = { phone: phone, device_id: device_id }
-      body[:method]        = method        if method
-      body[:app_name]      = app_name      if app_name
-      body[:template_code] = template_code if template_code
+    def send_otp_v2(phone:, method: nil, app_name: nil, device_id: nil, waba_id: nil,
+                    template_name: nil, custom_message: nil)
+      body = { phone: phone }
+      body[:method]         = method         if method
+      body[:app_name]       = app_name       if app_name
+      body[:device_id]      = device_id      if device_id
+      body[:waba_id]        = waba_id        if waba_id
+      body[:template_name]  = template_name  if template_name
       body[:custom_message] = custom_message if custom_message
       post('/v2/otp/send', body)
     end
@@ -109,27 +201,49 @@ module Kirimi
       post('/v2/otp/verify', { phone: phone, otp_code: otp_code })
     end
 
-    # --- Broadcast ---
+    # --- OTP Reverse ---
 
-    def broadcast_message(device_id:, phones:, message:, delay: nil)
-      phones_str = phones.is_a?(Array) ? phones.join(',') : phones
-      body = { device_id: device_id, phones: phones_str, message: message }
-      body[:delay] = delay if delay
-      post('/v1/broadcast-message', body)
+    def otp_reverse_create(phone:, device_id:, app_name: nil, callback_url: nil,
+                           custom_message: nil, success_message: nil, failure_message: nil)
+      body = { phone: phone, device_id: device_id }
+      body[:app_name]        = app_name        if app_name
+      body[:callback_url]    = callback_url    if callback_url
+      body[:custom_message]  = custom_message  if custom_message
+      body[:success_message] = success_message if success_message
+      body[:failure_message] = failure_message if failure_message
+      post('/v2/otp-reverse/create', body)
     end
 
-    # --- Deposits ---
-
-    def list_deposits(status: nil)
-      body = {}
-      body[:status] = status if status
-      post('/v1/list-deposits', body)
+    def otp_reverse_status(token:)
+      post('/v2/otp-reverse/status', { token: token })
     end
 
+    # --- Packages & Deposits ---
+
     def list_packages
       post('/v1/list-packages', {})
     end
 
+    def create_deposit(nominal:)
+      post('/v1/create-deposit', { nominal: nominal })
+    end
+
+    def deposit_status(ref:)
+      post('/v1/deposit-status', { ref: ref })
+    end
+
+    def cancel_deposit(ref:)
+      post('/v1/cancel-deposit', { ref: ref })
+    end
+
+    def list_deposits(page: nil, limit: nil, status: nil)
+      body = {}
+      body[:page]   = page   if page
+      body[:limit]  = limit  if limit
+      body[:status] = status if status
+      post('/v1/list-deposits', body)
+    end
+
     private
 
     def auth_params
@@ -213,6 +327,3 @@ module Kirimi
     end
   end
 end
-
-# Lazy require SecureRandom (part of stdlib, always available)
-require 'securerandom'

data/lib/kirimi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kirimi
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/spec/client_spec.rb

@@ -0,0 +1,817 @@
+# frozen_string_literal: true
+
+RSpec.describe Kirimi::Client do
+  let(:user_code) { 'TEST_USER' }
+  let(:secret)    { 'TEST_SECRET' }
+  let(:client)    { described_class.new(user_code: user_code, secret: secret) }
+  let(:base_url)  { 'https://api.kirimi.id' }
+
+  OK = { 'success' => true, 'data' => nil, 'message' => 'ok' }.freeze
+
+  # Stub a POST and assert the exact JSON body sent on the wire.
+  def stub_post_exact(path, expected_body, response_body: OK, status: 200)
+    stub_request(:post, "#{base_url}#{path}")
+      .with(
+        body: expected_body,
+        headers: {
+          'Content-Type' => 'application/json',
+          'Accept'       => 'application/json'
+        }
+      )
+      .to_return(
+        status: status,
+        body:   response_body.to_json,
+        headers: { 'Content-Type' => 'application/json' }
+      )
+  end
+
+  def auth
+    { 'user_code' => user_code, 'secret' => secret }
+  end
+
+  # Stub a POST; the returned holder's #body holds the parsed JSON body sent.
+  def capture_post(path, response_body: OK, status: 200)
+    holder = Struct.new(:body).new(nil)
+    stub_request(:post, "#{base_url}#{path}")
+      .with do |req|
+        holder.body = JSON.parse(req.body)
+        true
+      end
+      .to_return(
+        status: status,
+        body:   response_body.to_json,
+        headers: { 'Content-Type' => 'application/json' }
+      )
+    holder
+  end
+
+  # --- WhatsApp Unofficial ---
+
+  describe '#send_message' do
+    it 'sends receiver (never phone) and returns a Response' do
+      stub_post_exact(
+        '/v1/send-message',
+        auth.merge(
+          'device_id' => 'DEV1',
+          'receiver'  => '628111222333',
+          'message'   => 'Hello!'
+        ),
+        response_body: { 'success' => true, 'data' => { 'id' => 'msg_1' }, 'message' => 'Message sent' }
+      )
+
+      resp = client.send_message(device_id: 'DEV1', receiver: '628111222333', message: 'Hello!')
+
+      expect(resp).to be_a(Kirimi::Response)
+      expect(resp.success?).to be true
+      expect(resp.data).to eq('id' => 'msg_1')
+      expect(resp.message).to eq('Message sent')
+    end
+
+    it 'never sends a phone key' do
+      captured = capture_post('/v1/send-message')
+
+      client.send_message(device_id: 'DEV1', receiver: '628111222333', message: 'Hi')
+
+      expect(captured.body).not_to have_key('phone')
+      expect(captured.body['receiver']).to eq('628111222333')
+    end
+
+    it 'includes all optional params when provided' do
+      stub_post_exact(
+        '/v1/send-message',
+        auth.merge(
+          'device_id'          => 'DEV1',
+          'receiver'           => '628111',
+          'message'            => 'Check this',
+          'media_url'          => 'https://example.com/img.jpg',
+          'fileName'           => 'img.jpg',
+          'enableTypingEffect' => true,
+          'typingSpeedMs'      => 350,
+          'quotedMessageId'    => 'wamid.1'
+        )
+      )
+
+      resp = client.send_message(
+        device_id:            'DEV1',
+        receiver:             '628111',
+        message:              'Check this',
+        media_url:            'https://example.com/img.jpg',
+        file_name:            'img.jpg',
+        enable_typing_effect: true,
+        typing_speed_ms:      350,
+        quoted_message_id:    'wamid.1'
+      )
+
+      expect(resp.success?).to be true
+    end
+
+    it 'omits optional params when nil' do
+      captured = capture_post('/v1/send-message')
+
+      client.send_message(device_id: 'DEV1', receiver: '628111', message: 'Hi')
+
+      expect(captured.body).to eq(
+        auth.merge('device_id' => 'DEV1', 'receiver' => '628111', 'message' => 'Hi')
+      )
+    end
+
+    it 'keeps enableTypingEffect false rather than dropping it' do
+      captured = capture_post('/v1/send-message')
+
+      client.send_message(device_id: 'DEV1', receiver: '628111', message: 'Hi',
+                          enable_typing_effect: false)
+
+      expect(captured.body).to have_key('enableTypingEffect')
+      expect(captured.body['enableTypingEffect']).to be false
+    end
+  end
+
+  describe '#send_message_fast' do
+    it 'sends receiver and omits typing-effect params' do
+      captured = capture_post('/v1/send-message-fast')
+
+      client.send_message_fast(
+        device_id: 'DEV1',
+        receiver:  '628111',
+        message:   'Fast',
+        media_url: 'https://example.com/a.jpg',
+        file_name: 'a.jpg',
+        quoted_message_id: 'wamid.2'
+      )
+
+      expect(captured.body).to eq(
+        auth.merge(
+          'device_id'       => 'DEV1',
+          'receiver'        => '628111',
+          'message'         => 'Fast',
+          'media_url'       => 'https://example.com/a.jpg',
+          'fileName'        => 'a.jpg',
+          'quotedMessageId' => 'wamid.2'
+        )
+      )
+      expect(captured.body).not_to have_key('phone')
+      expect(captured.body).not_to have_key('enableTypingEffect')
+    end
+  end
+
+  describe '#send_message_file' do
+    let(:tmpfile) { Tempfile.new(['kirimi', '.txt']) }
+
+    after { tmpfile.close! }
+
+    it 'sends receiver instead of phone in the multipart body' do
+      stub_request(:post, "#{base_url}/v1/send-message-file").to_return(
+        status: 200,
+        body:   OK.to_json,
+        headers: { 'Content-Type' => 'application/json' }
+      )
+
+      resp = client.send_message_file(
+        device_id: 'DEV1',
+        receiver:  '628111',
+        file:      tmpfile.path,
+        file_name: 'notes.txt',
+        message:   'caption text'
+      )
+
+      expect(resp.success?).to be true
+      expect(
+        a_request(:post, "#{base_url}/v1/send-message-file")
+          .with { |req| req.body.include?('name="receiver"') && !req.body.include?('name="phone"') }
+      ).to have_been_made.once
+    end
+  end
+
+  describe '#broadcast_message' do
+    it 'sends numbers as an Array and requires label' do
+      captured = capture_post('/v1/broadcast-message')
+
+      client.broadcast_message(
+        device_id: 'DEV1',
+        label:     'promo-juli',
+        numbers:   %w[628111 628222 628333],
+        message:   'Promo!'
+      )
+
+      expect(captured.body).to eq(
+        auth.merge(
+          'device_id' => 'DEV1',
+          'label'     => 'promo-juli',
+          'numbers'   => %w[628111 628222 628333],
+          'message'   => 'Promo!'
+        )
+      )
+      expect(captured.body['numbers']).to be_an(Array)
+      expect(captured.body).not_to have_key('phones')
+    end
+
+    it 'does not join numbers into a comma string' do
+      captured = capture_post('/v1/broadcast-message')
+
+      client.broadcast_message(device_id: 'DEV1', label: 'x', numbers: %w[628111 628222], message: 'Hi')
+
+      expect(captured.body['numbers']).to eq(%w[628111 628222])
+    end
+
+    it 'includes optional scheduling params' do
+      captured = capture_post('/v1/broadcast-message')
+
+      client.broadcast_message(
+        device_id:            'DEV1',
+        label:                'sched',
+        numbers:              %w[628111],
+        message:              'Later',
+        delay:                60,
+        delay_min:            30,
+        delay_max:            3600,
+        media_url:            'https://example.com/p.jpg',
+        file_name:            'p.jpg',
+        started_at:           '2026-01-01T00:00:00Z',
+        enable_typing_effect: true,
+        typing_speed_ms:      200
+      )
+
+      expect(captured.body).to include(
+        'delay'              => 60,
+        'delayMin'           => 30,
+        'delayMax'           => 3600,
+        'media_url'          => 'https://example.com/p.jpg',
+        'fileName'           => 'p.jpg',
+        'started_at'         => '2026-01-01T00:00:00Z',
+        'enableTypingEffect' => true,
+        'typingSpeedMs'      => 200
+      )
+    end
+  end
+
+  # --- WABA ---
+
+  describe '#send_waba_message' do
+    it 'sends waba_id, to and template_name' do
+      captured = capture_post('/v1/waba/send-message')
+
+      client.send_waba_message(
+        waba_id:       'WABA1',
+        to:            '628111',
+        template_name: 'order_confirmation'
+      )
+
+      expect(captured.body).to eq(
+        auth.merge('waba_id' => 'WABA1', 'to' => '628111', 'template_name' => 'order_confirmation')
+      )
+      expect(captured.body).not_to have_key('device_id')
+      expect(captured.body).not_to have_key('phone')
+    end
+
+    it 'includes variables, header and buttons' do
+      captured = capture_post('/v1/waba/send-message')
+
+      client.send_waba_message(
+        waba_id:       'WABA1',
+        to:            '628111',
+        template_name: 'promo',
+        variables:     %w[Alice 100],
+        header:        { 'type' => 'text', 'text' => 'Hi' },
+        buttons:       [{ 'type' => 'url', 'url' => 'https://x.test' }]
+      )
+
+      expect(captured.body['variables']).to eq(%w[Alice 100])
+      expect(captured.body['header']).to eq('type' => 'text', 'text' => 'Hi')
+      expect(captured.body['buttons']).to eq([{ 'type' => 'url', 'url' => 'https://x.test' }])
+    end
+
+    it 'omits optional fields when nil' do
+      captured = capture_post('/v1/waba/send-message')
+
+      client.send_waba_message(waba_id: 'WABA1', to: '628111', template_name: 't')
+
+      expect(captured.body.keys).to contain_exactly('user_code', 'secret', 'waba_id', 'to', 'template_name')
+    end
+  end
+
+  describe '#waba_reply' do
+    it 'sends waba_id, to and the message object' do
+      captured = capture_post('/v1/waba/messages/reply')
+
+      client.waba_reply(waba_id: 'WABA1', to: '628111', message: { 'type' => 'text', 'text' => 'halo' })
+
+      expect(captured.body).to eq(
+        auth.merge('waba_id' => 'WABA1', 'to' => '628111',
+                   'message' => { 'type' => 'text', 'text' => 'halo' })
+      )
+    end
+  end
+
+  describe '#waba_conversations' do
+    it 'sends no pagination params when omitted' do
+      captured = capture_post('/v1/waba/conversations')
+
+      client.waba_conversations
+
+      expect(captured.body).to eq(auth)
+    end
+
+    it 'sends limit and page when provided' do
+      captured = capture_post('/v1/waba/conversations')
+
+      client.waba_conversations(limit: 25, page: 2)
+
+      expect(captured.body).to eq(auth.merge('limit' => 25, 'page' => 2))
+    end
+  end
+
+  describe '#waba_templates_sync' do
+    it 'sends waba_id' do
+      captured = capture_post('/v1/waba/templates/sync')
+
+      client.waba_templates_sync(waba_id: 'WABA1')
+
+      expect(captured.body).to eq(auth.merge('waba_id' => 'WABA1'))
+    end
+  end
+
+  describe '#waba_send_otp' do
+    it 'sends waba_id, to and template_name' do
+      captured = capture_post('/v1/waba/send-otp')
+
+      client.waba_send_otp(waba_id: 'WABA1', to: '628111', template_name: 'auth_otp')
+
+      expect(captured.body).to eq(
+        auth.merge('waba_id' => 'WABA1', 'to' => '628111', 'template_name' => 'auth_otp')
+      )
+    end
+  end
+
+  describe '#waba_verify_otp' do
+    it 'sends waba_id, to and otp_code' do
+      captured = capture_post('/v1/waba/verify-otp')
+
+      client.waba_verify_otp(waba_id: 'WABA1', to: '628111', otp_code: '123456')
+
+      expect(captured.body).to eq(
+        auth.merge('waba_id' => 'WABA1', 'to' => '628111', 'otp_code' => '123456')
+      )
+    end
+  end
+
+  # --- Devices ---
+
+  describe '#create_device' do
+    it 'sends package_id only' do
+      captured = capture_post('/v1/create-device')
+
+      client.create_device(package_id: 'PKG1')
+
+      expect(captured.body).to eq(auth.merge('package_id' => 'PKG1'))
+    end
+
+    it 'sends voucher_code when provided' do
+      captured = capture_post('/v1/create-device')
+
+      client.create_device(package_id: 7, voucher_code: 'PROMO10')
+
+      expect(captured.body).to eq(auth.merge('package_id' => 7, 'voucher_code' => 'PROMO10'))
+    end
+  end
+
+  describe '#connect_device' do
+    it 'sends device_id' do
+      captured = capture_post('/v1/connect-device')
+
+      client.connect_device(device_id: 'DEV1')
+
+      expect(captured.body).to eq(auth.merge('device_id' => 'DEV1'))
+    end
+  end
+
+  describe '#renew_device' do
+    it 'sends device_id and package_id' do
+      captured = capture_post('/v1/renew-device')
+
+      client.renew_device(device_id: 'DEV1', package_id: 'PKG1')
+
+      expect(captured.body).to eq(auth.merge('device_id' => 'DEV1', 'package_id' => 'PKG1'))
+    end
+
+    it 'sends voucher_code when provided' do
+      captured = capture_post('/v1/renew-device')
+
+      client.renew_device(device_id: 'DEV1', package_id: 'PKG1', voucher_code: 'VOUCH')
+
+      expect(captured.body).to eq(
+        auth.merge('device_id' => 'DEV1', 'package_id' => 'PKG1', 'voucher_code' => 'VOUCH')
+      )
+    end
+  end
+
+  describe '#list_devices' do
+    it 'sends no pagination params when omitted' do
+      captured = capture_post('/v1/list-devices')
+
+      client.list_devices
+
+      expect(captured.body).to eq(auth)
+    end
+
+    it 'sends page and limit when provided' do
+      captured = capture_post('/v1/list-devices')
+
+      client.list_devices(page: 3, limit: 50)
+
+      expect(captured.body).to eq(auth.merge('page' => 3, 'limit' => 50))
+    end
+  end
+
+  describe '#device_status' do
+    it 'sends device_id' do
+      captured = capture_post('/v1/device-status')
+
+      client.device_status(device_id: 'DEV1')
+
+      expect(captured.body).to eq(auth.merge('device_id' => 'DEV1'))
+    end
+  end
+
+  describe '#device_status_enhanced' do
+    it 'sends device_id' do
+      captured = capture_post('/v1/device-status-enhanced')
+
+      client.device_status_enhanced(device_id: 'DEV1')
+
+      expect(captured.body).to eq(auth.merge('device_id' => 'DEV1'))
+    end
+  end
+
+  # --- Contacts ---
+
+  describe '#save_contact' do
+    it 'sends nama and nomor (never name/phone)' do
+      captured = capture_post('/v1/save-contact')
+
+      client.save_contact(nama: 'Budi', nomor: '628111')
+
+      expect(captured.body).to eq(auth.merge('nama' => 'Budi', 'nomor' => '628111'))
+      expect(captured.body).not_to have_key('name')
+      expect(captured.body).not_to have_key('phone')
+    end
+
+    it 'sends device_id when provided' do
+      captured = capture_post('/v1/save-contact')
+
+      client.save_contact(nama: 'Budi', nomor: '628111', device_id: 'DEV1')
+
+      expect(captured.body).to eq(
+        auth.merge('nama' => 'Budi', 'nomor' => '628111', 'device_id' => 'DEV1')
+      )
+    end
+  end
+
+  describe '#save_contacts_bulk' do
+    it 'sends contacts as an array of nama/nomor' do
+      captured = capture_post('/v1/save-contacts-bulk')
+
+      client.save_contacts_bulk(
+        contacts: [{ nama: 'Budi', nomor: '628111' }, { nama: 'Ani', nomor: '628222' }]
+      )
+
+      expect(captured.body).to eq(
+        auth.merge(
+          'contacts' => [{ 'nama' => 'Budi', 'nomor' => '628111' },
+                         { 'nama' => 'Ani', 'nomor' => '628222' }]
+        )
+      )
+      expect(captured.body['contacts']).to be_an(Array)
+    end
+
+    it 'sends device_id when provided' do
+      captured = capture_post('/v1/save-contacts-bulk')
+
+      client.save_contacts_bulk(contacts: [{ nama: 'Budi', nomor: '628111' }], device_id: 'DEV1')
+
+      expect(captured.body['device_id']).to eq('DEV1')
+    end
+  end
+
+  # --- OTP v1 ---
+
+  describe '#generate_otp' do
+    it 'sends snake_case otp_length/otp_type plus camelCase custom text fields' do
+      captured = capture_post('/v1/generate-otp')
+
+      client.generate_otp(
+        device_id:          'DEV1',
+        phone:              '628111',
+        otp_length:         6,
+        otp_type:           'numeric',
+        custom_otp_text:    'Kirimi',
+        custom_otp_message: 'Your OTP is {otp}'
+      )
+
+      expect(captured.body).to eq(
+        auth.merge(
+          'device_id'        => 'DEV1',
+          'phone'            => '628111',
+          'otp_length'       => 6,
+          'otp_type'         => 'numeric',
+          'customOtpText'    => 'Kirimi',
+          'customOtpMessage' => 'Your OTP is {otp}'
+        )
+      )
+      expect(captured.body).not_to have_key('otpLength')
+      expect(captured.body).not_to have_key('otpType')
+    end
+
+    it 'includes typing effect params when provided' do
+      captured = capture_post('/v1/generate-otp')
+
+      client.generate_otp(device_id: 'DEV1', phone: '628111',
+                          enable_typing_effect: true, typing_speed_ms: 300)
+
+      expect(captured.body).to include('enableTypingEffect' => true, 'typingSpeedMs' => 300)
+    end
+
+    it 'omits optional fields when nil' do
+      captured = capture_post('/v1/generate-otp')
+
+      client.generate_otp(device_id: 'DEV1', phone: '628111')
+
+      expect(captured.body).to eq(auth.merge('device_id' => 'DEV1', 'phone' => '628111'))
+    end
+  end
+
+  describe '#validate_otp' do
+    it 'sends device_id, phone and otp' do
+      captured = capture_post('/v1/validate-otp')
+
+      client.validate_otp(device_id: 'DEV1', phone: '628111', otp: '123456')
+
+      expect(captured.body).to eq(
+        auth.merge('device_id' => 'DEV1', 'phone' => '628111', 'otp' => '123456')
+      )
+    end
+  end
+
+  # --- OTP v2 ---
+
+  describe '#send_otp_v2' do
+    it 'supports method whatsapp with app_name only' do
+      captured = capture_post('/v2/otp/send')
+
+      client.send_otp_v2(phone: '628111', method: 'whatsapp', app_name: 'MyApp')
+
+      expect(captured.body).to eq(
+        auth.merge('phone' => '628111', 'method' => 'whatsapp', 'app_name' => 'MyApp')
+      )
+    end
+
+    it 'supports method device with device_id and custom_message' do
+      captured = capture_post('/v2/otp/send')
+
+      client.send_otp_v2(
+        phone:          '628111',
+        method:         'device',
+        device_id:      'DEV1',
+        custom_message: 'Your OTP is {{otp}}'
+      )
+
+      expect(captured.body).to eq(
+        auth.merge('phone' => '628111', 'method' => 'device', 'device_id' => 'DEV1',
+                   'custom_message' => 'Your OTP is {{otp}}')
+      )
+      expect(captured.body).not_to have_key('waba_id')
+    end
+
+    it 'supports method waba_user with waba_id and template_name' do
+      captured = capture_post('/v2/otp/send')
+
+      client.send_otp_v2(
+        phone:         '628111',
+        method:        'waba_user',
+        waba_id:       'WABA1',
+        template_name: 'auth_otp'
+      )
+
+      expect(captured.body).to eq(
+        auth.merge('phone' => '628111', 'method' => 'waba_user', 'waba_id' => 'WABA1',
+                   'template_name' => 'auth_otp')
+      )
+      expect(captured.body).not_to have_key('device_id')
+      expect(captured.body).not_to have_key('template_code')
+    end
+
+    it 'sends only phone when method is omitted' do
+      captured = capture_post('/v2/otp/send')
+
+      client.send_otp_v2(phone: '628111')
+
+      expect(captured.body).to eq(auth.merge('phone' => '628111'))
+    end
+  end
+
+  describe '#verify_otp_v2' do
+    it 'sends phone and otp_code' do
+      captured = capture_post('/v2/otp/verify')
+
+      client.verify_otp_v2(phone: '628111', otp_code: '123456')
+
+      expect(captured.body).to eq(auth.merge('phone' => '628111', 'otp_code' => '123456'))
+    end
+  end
+
+  # --- OTP Reverse ---
+
+  describe '#otp_reverse_create' do
+    it 'sends required phone and device_id' do
+      captured = capture_post('/v2/otp-reverse/create')
+
+      client.otp_reverse_create(phone: '628111', device_id: 'DEV1')
+
+      expect(captured.body).to eq(auth.merge('phone' => '628111', 'device_id' => 'DEV1'))
+    end
+
+    it 'sends every optional field when provided' do
+      captured = capture_post('/v2/otp-reverse/create')
+
+      client.otp_reverse_create(
+        phone:           '628111',
+        device_id:       'DEV1',
+        app_name:        'MyApp',
+        callback_url:    'https://cb.test/hook',
+        custom_message:  'Kirim {{token}} dari {{phone}}',
+        success_message: 'Berhasil',
+        failure_message: 'Gagal'
+      )
+
+      expect(captured.body).to eq(
+        auth.merge(
+          'phone'           => '628111',
+          'device_id'       => 'DEV1',
+          'app_name'        => 'MyApp',
+          'callback_url'    => 'https://cb.test/hook',
+          'custom_message'  => 'Kirim {{token}} dari {{phone}}',
+          'success_message' => 'Berhasil',
+          'failure_message' => 'Gagal'
+        )
+      )
+    end
+  end
+
+  describe '#otp_reverse_status' do
+    it 'sends token' do
+      captured = capture_post('/v2/otp-reverse/status')
+
+      client.otp_reverse_status(token: '01HZZTOKEN')
+
+      expect(captured.body).to eq(auth.merge('token' => '01HZZTOKEN'))
+    end
+  end
+
+  # --- Packages & Deposits ---
+
+  describe '#list_packages' do
+    it 'sends only auth' do
+      captured = capture_post('/v1/list-packages')
+
+      resp = client.list_packages
+
+      expect(captured.body).to eq(auth)
+      expect(resp.success?).to be true
+    end
+  end
+
+  describe '#create_deposit' do
+    it 'sends nominal' do
+      captured = capture_post('/v1/create-deposit')
+
+      client.create_deposit(nominal: 50_000)
+
+      expect(captured.body).to eq(auth.merge('nominal' => 50_000))
+    end
+  end
+
+  describe '#deposit_status' do
+    it 'sends ref' do
+      captured = capture_post('/v1/deposit-status')
+
+      client.deposit_status(ref: 'DEP123')
+
+      expect(captured.body).to eq(auth.merge('ref' => 'DEP123'))
+    end
+  end
+
+  describe '#cancel_deposit' do
+    it 'sends ref' do
+      captured = capture_post('/v1/cancel-deposit')
+
+      client.cancel_deposit(ref: 'DEP123')
+
+      expect(captured.body).to eq(auth.merge('ref' => 'DEP123'))
+    end
+  end
+
+  describe '#list_deposits' do
+    it 'sends no params when omitted' do
+      captured = capture_post('/v1/list-deposits')
+
+      client.list_deposits
+
+      expect(captured.body).to eq(auth)
+    end
+
+    it 'sends page, limit and status when provided' do
+      captured = capture_post('/v1/list-deposits')
+
+      client.list_deposits(page: 1, limit: 10, status: 'unpaid')
+
+      expect(captured.body).to eq(auth.merge('page' => 1, 'limit' => 10, 'status' => 'unpaid'))
+    end
+  end
+
+  # --- User ---
+
+  describe '#user_info' do
+    it 'sends only auth and wraps the response' do
+      captured = capture_post(
+        '/v1/user-info',
+        response_body: {
+          'success' => true,
+          'data'    => { 'name' => 'John Doe', 'email' => 'john@example.com' },
+          'message' => 'OK'
+        }
+      )
+
+      resp = client.user_info
+
+      expect(captured.body).to eq(auth)
+      expect(resp).to be_a(Kirimi::Response)
+      expect(resp.success).to be true
+      expect(resp.success?).to be true
+      expect(resp.data['name']).to eq('John Doe')
+      expect(resp.raw).to be_a(Hash)
+      expect(resp.raw['success']).to be true
+    end
+  end
+
+  # --- Error handling ---
+
+  describe 'error handling' do
+    it 'raises ApiError with status_code 401 on 401' do
+      stub_post_exact(
+        '/v1/user-info',
+        auth,
+        response_body: { 'success' => false, 'message' => 'Unauthorized' },
+        status: 401
+      )
+
+      expect { client.user_info }.to raise_error(Kirimi::ApiError) do |err|
+        expect(err.status_code).to eq(401)
+        expect(err.message).to eq('Unauthorized')
+        expect(err).to be_a(Kirimi::Error)
+      end
+    end
+
+    it 'raises ApiError with status_code 402 when balance is insufficient' do
+      stub_post_exact(
+        '/v2/otp/send',
+        auth.merge('phone' => '628111', 'method' => 'whatsapp'),
+        response_body: { 'success' => false, 'message' => 'Insufficient balance' },
+        status: 402
+      )
+
+      expect { client.send_otp_v2(phone: '628111', method: 'whatsapp') }
+        .to raise_error(Kirimi::ApiError) { |err| expect(err.status_code).to eq(402) }
+    end
+
+    it 'raises ApiError with status_code 500 on server error' do
+      stub_post_exact(
+        '/v1/list-devices',
+        auth,
+        response_body: { 'success' => false, 'message' => 'Internal Server Error' },
+        status: 500
+      )
+
+      expect { client.list_devices }.to raise_error(Kirimi::ApiError) do |err|
+        expect(err.status_code).to eq(500)
+      end
+    end
+
+    it 'exposes the parsed body on the error' do
+      stub_post_exact(
+        '/v1/user-info',
+        auth,
+        response_body: { 'success' => false, 'message' => 'Unauthorized' },
+        status: 401
+      )
+
+      expect { client.user_info }.to raise_error(Kirimi::ApiError) do |err|
+        expect(err.response_data).to eq('success' => false, 'message' => 'Unauthorized')
+      end
+    end
+
+    it 'raises NetworkError when the connection fails' do
+      stub_request(:post, "#{base_url}/v1/user-info").to_raise(SocketError.new('getaddrinfo failed'))
+
+      expect { client.user_info }.to raise_error(Kirimi::NetworkError, /Network error/)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kirimi
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Kirimi
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-14 00:00:00.000000000 Z
+date: 2026-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -24,6 +24,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.19'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.19'
 description: Send WhatsApp messages, OTP, broadcasts, and more via the Kirimi API.
 email:
 - support@kirimi.id
@@ -40,7 +68,7 @@ files:
 - lib/kirimi/errors.rb
 - lib/kirimi/response.rb
 - lib/kirimi/version.rb
-- test/client_test.rb
+- spec/client_spec.rb
 homepage: https://github.com/kiriminow/kirimi-ruby
 licenses:
 - MIT
@@ -48,7 +76,7 @@ metadata:
   homepage_uri: https://github.com/kiriminow/kirimi-ruby
   source_code_uri: https://github.com/kiriminow/kirimi-ruby
   changelog_uri: https://github.com/kiriminow/kirimi-ruby/blob/main/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -63,9 +91,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Official Ruby SDK for Kirimi WhatsApp API
 test_files:
-- test/client_test.rb
+- spec/client_spec.rb

data/test/client_test.rb

@@ -1,160 +0,0 @@
-# frozen_string_literal: true
-
-require 'minitest/autorun'
-require 'minitest/pride'
-require 'json'
-require 'ostruct'
-
-$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
-require 'kirimi'
-
-# Minimal HTTP response stub
-FakeResponse = Struct.new(:code, :body, :message) do
-  def [](key); nil; end
-end
-
-# Captures the last request body sent via Net::HTTP
-module NetHTTPStub
-  @stub_status   = 200
-  @stub_body     = {}
-  @last_body     = nil
-  @last_path     = nil
-
-  class << self
-    attr_accessor :stub_status, :stub_body, :last_body, :last_path
-
-    def setup(status:, body:)
-      @stub_status = status
-      @stub_body   = body
-      @last_body   = nil
-      @last_path   = nil
-    end
-  end
-end
-
-# Monkey-patch Net::HTTP for tests only
-module Net
-  class HTTP
-    def request(req)
-      NetHTTPStub.last_body = JSON.parse(req.body) rescue req.body
-      NetHTTPStub.last_path = req.path
-      FakeResponse.new(
-        NetHTTPStub.stub_status.to_s,
-        NetHTTPStub.stub_body.to_json,
-        'OK'
-      )
-    end
-  end
-end
-
-class ClientTest < Minitest::Test
-  def setup
-    @client = Kirimi::Client.new(user_code: 'USER', secret: 'SECRET')
-  end
-
-  def stub(status: 200, body: { 'success' => true, 'data' => nil, 'message' => 'ok' })
-    NetHTTPStub.setup(status: status, body: body)
-  end
-
-  # ---- send_message ----
-
-  def test_send_message_correct_body
-    stub(body: { 'success' => true, 'data' => { 'id' => 'msg_1' }, 'message' => 'sent' })
-
-    resp = @client.send_message(device_id: 'DEV1', phone: '628111', message: 'Hello!')
-
-    assert_equal 'USER',   NetHTTPStub.last_body['user_code']
-    assert_equal 'SECRET', NetHTTPStub.last_body['secret']
-    assert_equal 'DEV1',   NetHTTPStub.last_body['device_id']
-    assert_equal '628111', NetHTTPStub.last_body['phone']
-    assert_equal 'Hello!', NetHTTPStub.last_body['message']
-    assert_instance_of Kirimi::Response, resp
-    assert resp.success?
-    assert_equal 'msg_1', resp.data['id']
-  end
-
-  def test_send_message_includes_media_url
-    stub
-    @client.send_message(device_id: 'DEV1', phone: '628111', message: 'pic', media_url: 'https://img.example.com/a.jpg')
-    assert_equal 'https://img.example.com/a.jpg', NetHTTPStub.last_body['media_url']
-  end
-
-  def test_send_message_omits_media_url_when_nil
-    stub
-    @client.send_message(device_id: 'DEV1', phone: '628111', message: 'hi')
-    refute NetHTTPStub.last_body.key?('media_url')
-  end
-
-  # ---- generate_otp ----
-
-  def test_generate_otp_with_optional_params
-    stub(body: { 'success' => true, 'data' => { 'otp' => '123456' }, 'message' => 'OTP sent' })
-
-    resp = @client.generate_otp(
-      device_id:          'DEV1',
-      phone:              '628111',
-      otp_length:         6,
-      otp_type:           'numeric',
-      custom_otp_message: 'Your code is {otp}'
-    )
-
-    assert_equal 6,                   NetHTTPStub.last_body['otp_length']
-    assert_equal 'numeric',           NetHTTPStub.last_body['otp_type']
-    assert_equal 'Your code is {otp}', NetHTTPStub.last_body['customOtpMessage']
-    assert resp.success?
-    assert_equal '123456', resp.data['otp']
-  end
-
-  def test_generate_otp_omits_optional_when_nil
-    stub
-    @client.generate_otp(device_id: 'DEV1', phone: '628111')
-    refute NetHTTPStub.last_body.key?('otp_length')
-    refute NetHTTPStub.last_body.key?('customOtpMessage')
-  end
-
-  # ---- error handling ----
-
-  def test_raises_api_error_on_401
-    stub(status: 401, body: { 'success' => false, 'message' => 'Unauthorized' })
-
-    err = assert_raises(Kirimi::ApiError) { @client.user_info }
-    assert_equal 401,            err.status_code
-    assert_equal 'Unauthorized', err.message
-  end
-
-  def test_raises_api_error_on_500
-    stub(status: 500, body: { 'success' => false, 'message' => 'Server Error' })
-
-    err = assert_raises(Kirimi::ApiError) { @client.list_devices }
-    assert_equal 500, err.status_code
-  end
-
-  # ---- response wrapping ----
-
-  def test_response_wraps_data_correctly
-    stub(body: { 'success' => true, 'data' => { 'name' => 'John' }, 'message' => 'OK' })
-
-    resp = @client.user_info
-
-    assert_instance_of Kirimi::Response, resp
-    assert resp.success?
-    assert_equal true,   resp.success
-    assert_equal 'John', resp.data['name']
-    assert_equal 'OK',   resp.message
-    assert_instance_of Hash, resp.raw
-  end
-
-  # ---- broadcast phones array ----
-
-  def test_broadcast_joins_phones_array
-    stub
-    @client.broadcast_message(device_id: 'DEV1', phones: %w[628111 628222 628333], message: 'Promo!')
-    assert_equal '628111,628222,628333', NetHTTPStub.last_body['phones']
-  end
-
-  def test_broadcast_accepts_phones_string
-    stub
-    @client.broadcast_message(device_id: 'DEV1', phones: '628111,628222', message: 'Hi')
-    assert_equal '628111,628222', NetHTTPStub.last_body['phones']
-  end
-end