whatsapp_notifier 0.2.0

data/spec/client_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+RSpec.describe WhatsAppNotifier::Client do
+  let(:config) { WhatsAppNotifier::Configuration.new }
+
+  it "routes to web automation provider by default" do
+    Dir.mktmpdir do |dir|
+      config.provider = :web_automation
+      config.web_automation_enabled = true
+      config.web_session_path = File.join(dir, "session.json")
+      config.web_adapter = double(
+        send_message: { success: true, session: {} },
+        fetch_qr_code: "qr",
+        connection_status: { state: "AUTHENTICATED", authenticated: true }
+      )
+      client = described_class.new(configuration: config)
+
+      result = client.deliver(to: "+1", body: "h")
+      expect(result.provider).to eq(:web_automation)
+    end
+  end
+
+  it "raises for unknown provider" do
+    client = described_class.new(configuration: config)
+    expect { client.deliver(to: "+1", body: "h", provider: :bad) }.to raise_error(WhatsAppNotifier::ConfigurationError, /unknown provider/)
+  end
+
+  it "delegates bulk and qr operations" do
+    Dir.mktmpdir do |dir|
+      config.provider = :web_automation
+      config.bulk_base_delay_seconds = 0
+      config.bulk_jitter_seconds = 0
+      config.web_automation_enabled = true
+      config.web_session_path = File.join(dir, "session.json")
+      config.web_adapter = double(
+        send_message: { success: true, session: {} },
+        fetch_qr_code: "qr",
+        connection_status: { state: "QR_REQUIRED", authenticated: false }
+      )
+      client = described_class.new(configuration: config)
+
+      summary = client.deliver_bulk([{ to: "+1", body: "a" }], sleeper: ->(_seconds) {})
+      expect(summary[:success]).to eq(1)
+
+      qr = client.scan_qr(provider: :web_automation)
+      expect(qr).to eq("qr")
+
+      status = client.connection_status(provider: :web_automation)
+      expect(status).to include(state: "QR_REQUIRED")
+    end
+  end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+RSpec.describe WhatsAppNotifier::Configuration do
+  it "has safe defaults" do
+    config = described_class.new
+
+    expect(config.provider).to eq(:web_automation)
+    expect(config.web_automation_enabled).to be(true)
+    expect(config.bulk_max_recipients).to be > 0
+  end
+
+  it "raises when provider is missing" do
+    config = described_class.new
+    config.provider = nil
+
+    expect { config.validate! }.to raise_error(WhatsAppNotifier::ConfigurationError, /provider is required/)
+  end
+
+  it "raises when bulk_max_recipients is invalid" do
+    config = described_class.new
+    config.bulk_max_recipients = 0
+
+    expect { config.validate! }.to raise_error(WhatsAppNotifier::ConfigurationError, /bulk_max_recipients/)
+  end
+
+  it "raises when bulk_max_attempts is invalid" do
+    config = described_class.new
+    config.bulk_max_attempts = 0
+
+    expect { config.validate! }.to raise_error(WhatsAppNotifier::ConfigurationError, /bulk_max_attempts/)
+  end
+
+  it "raises when provider is not web_automation" do
+    config = described_class.new
+    config.provider = :official_api
+    config.web_adapter = double(send_message: {}, fetch_qr_code: "qr", connection_status: {})
+
+    expect { config.validate! }.to raise_error(WhatsAppNotifier::ConfigurationError, /only :web_automation provider is supported/)
+  end
+
+  it "raises when web_adapter is missing required methods" do
+    config = described_class.new
+    config.web_adapter = Object.new
+
+    expect { config.validate! }.to raise_error(WhatsAppNotifier::ConfigurationError, /web_adapter must be configured/)
+  end
+end

data/spec/doctor_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+require "tmpdir"
+
+RSpec.describe WhatsAppNotifier::Doctor do
+  describe ".session_dir" do
+    it "uses provided env path when set" do
+      env = { "WHATSAPP_SESSION_DIR" => "/tmp/custom_sessions" }
+      expect(described_class.session_dir(env: env, app_root: "/app")).to eq("/tmp/custom_sessions")
+    end
+  end
+
+  describe ".run" do
+    it "returns true when dependencies and paths are valid" do
+      Dir.mktmpdir do |tmpdir|
+        env = {
+          "PUPPETEER_EXECUTABLE_PATH" => "/bin/sh",
+          "WHATSAPP_SESSION_DIR" => File.join(tmpdir, "sessions"),
+          "WHATSAPP_NOTIFIER_SERVICE_URL" => "http://127.0.0.1:3001"
+        }
+        io = StringIO.new
+
+        allow(described_class).to receive(:system).with("bun --version > /dev/null 2>&1").and_return(true)
+
+        expect(described_class.run(io: io, env: env, app_root: tmpdir)).to be(true)
+        expect(io.string).to include("PASS: Bun installed")
+      end
+    end
+
+    it "returns false and prints fixes when checks fail" do
+      Dir.mktmpdir do |tmpdir|
+        env = {
+          "PUPPETEER_EXECUTABLE_PATH" => "/missing/chrome",
+          "WHATSAPP_NOTIFIER_SERVICE_URL" => "not-a-url"
+        }
+        io = StringIO.new
+
+        allow(described_class).to receive(:system).with("bun --version > /dev/null 2>&1").and_return(false)
+        allow(FileUtils).to receive(:mkdir_p)
+        allow(File).to receive(:write).and_raise(Errno::EACCES)
+
+        expect(described_class.run(io: io, env: env, app_root: tmpdir)).to be(false)
+        expect(io.string).to include("Quick fixes:")
+      end
+    end
+  end
+end

data/spec/jobs/send_message_job_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+class JobNotification < WhatsAppNotifier::Notification
+  def message
+    "job message"
+  end
+end
+
+RSpec.describe WhatsAppNotifier::Jobs::SendMessageJob do
+  before do
+    WhatsAppNotifier.configure do |config|
+      config.provider = :web_automation
+      config.web_automation_enabled = true
+      config.web_adapter = double(
+        send_message: { success: true, session: {} },
+        fetch_qr_code: "qr",
+        connection_status: { state: "AUTHENTICATED", authenticated: true }
+      )
+    end
+  end
+
+  it "performs now by resolving class name" do
+    result = described_class.perform_now("JobNotification", to: "+1")
+    expect(result).to be_success
+  end
+
+  it "raises when perform_later has no active job base" do
+    hide_const("ActiveJob")
+    expect { described_class.perform_later("JobNotification", to: "+1") }.to raise_error(LoadError)
+  end
+
+  it "allows perform_later when active job base is present" do
+    stub_const("ActiveJob::Base", Class.new)
+    expect { described_class.perform_later("JobNotification", to: "+1") }.not_to raise_error
+  end
+end

data/spec/notification_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+
+class TestNotification < WhatsAppNotifier::Notification
+  template :hello, "Hi {{name}}"
+  to "+100"
+  provider :web_automation
+end
+
+class ExplicitMessageNotification < WhatsAppNotifier::Notification
+  def message
+    "direct-body"
+  end
+end
+
+RSpec.describe WhatsAppNotifier::Notification do
+  before do
+    WhatsAppNotifier.configure do |config|
+      config.provider = :web_automation
+      config.web_automation_enabled = true
+      config.web_adapter = double(
+        send_message: { success: true, metadata: {}, session: {} },
+        fetch_qr_code: "qr",
+        connection_status: { state: "AUTHENTICATED", authenticated: true }
+      )
+    end
+  end
+
+  it "delivers a template based notification" do
+    result = TestNotification.deliver_now(params: { name: "Neha" })
+    expect(result).to be_success
+  end
+
+  it "supports deliver_later when active job exists" do
+    stub_const("ActiveJob::Base", Class.new)
+    expect { TestNotification.deliver_later(params: { name: "Neha" }) }.not_to raise_error
+  end
+
+  it "raises for deliver_later without active job" do
+    hide_const("ActiveJob")
+    expect { TestNotification.deliver_later(params: { name: "Neha" }) }.to raise_error(LoadError)
+  end
+
+  it "raises when recipient is missing" do
+    expect { ExplicitMessageNotification.deliver_now }.to raise_error(WhatsAppNotifier::ConfigurationError, /recipient/)
+  end
+
+  it "raises when template not found" do
+    notification = TestNotification.with(template: :unknown)
+    expect { notification.message }.to raise_error(WhatsAppNotifier::ConfigurationError, /template not found/)
+  end
+
+  it "raises when neither message nor template exist" do
+    expect { WhatsAppNotifier::Notification.new.message }.to raise_error(NotImplementedError)
+  end
+
+  it "uses explicit message implementation" do
+    result = ExplicitMessageNotification.deliver_now(to: "+1")
+    expect(result).to be_success
+  end
+end

data/spec/providers/base_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+RSpec.describe WhatsAppNotifier::Providers::Base do
+  let(:provider) { described_class.new(configuration: WhatsAppNotifier.configuration) }
+
+  it "requires deliver implementation" do
+    expect { provider.deliver({}) }.to raise_error(NotImplementedError)
+  end
+
+  it "does not support qr by default" do
+    expect { provider.scan_qr }.to raise_error(NotImplementedError)
+  end
+
+  it "does not support connection status by default" do
+    expect { provider.connection_status }.to raise_error(NotImplementedError)
+  end
+end

data/spec/providers/web_automation_spec.rb

@@ -0,0 +1,109 @@
+require "spec_helper"
+
+RSpec.describe WhatsAppNotifier::Providers::WebAutomation do
+  def build_config(path:, adapter:, enabled: true, warn: true, logger: Logger.new(nil))
+    config = WhatsAppNotifier::Configuration.new
+    config.web_session_path = path
+    config.web_adapter = adapter
+    config.web_automation_enabled = enabled
+    config.warn_on_risky_provider = warn
+    config.logger = logger
+    config
+  end
+
+  it "raises on scan when provider disabled" do
+    Dir.mktmpdir do |dir|
+      adapter = double(fetch_qr_code: "qr", connection_status: {})
+      config = build_config(path: File.join(dir, "session.json"), adapter: adapter, enabled: false)
+      provider = described_class.new(configuration: config)
+
+      expect { provider.scan_qr }.to raise_error(WhatsAppNotifier::ConfigurationError, /disabled/)
+    end
+  end
+
+  it "scans qr when enabled" do
+    Dir.mktmpdir do |dir|
+      adapter = double(fetch_qr_code: "qr", connection_status: {})
+      config = build_config(path: File.join(dir, "session.json"), adapter: adapter)
+      provider = described_class.new(configuration: config)
+
+      expect(provider.scan_qr).to eq("qr")
+    end
+  end
+
+  it "delivers and persists session from adapter response" do
+    Dir.mktmpdir do |dir|
+      logger = double(warn: true)
+      adapter = double
+      allow(adapter).to receive(:send_message).and_return(
+        success: true,
+        message_id: "w1",
+        session: { active: true, token: "x" }
+      )
+      allow(adapter).to receive(:fetch_qr_code).and_return("qr")
+      allow(adapter).to receive(:connection_status).and_return(state: "AUTHENTICATED", authenticated: true)
+      config = build_config(path: File.join(dir, "session.json"), adapter: adapter, logger: logger)
+      provider = described_class.new(configuration: config)
+
+      result = provider.deliver(to: "+1", body: "h")
+      expect(result).to be_success
+      expect(result.message_id).to eq("w1")
+
+      provider.deliver(to: "+1", body: "h")
+      expect(logger).to have_received(:warn).once
+    end
+  end
+
+  it "returns failure on adapter error" do
+    Dir.mktmpdir do |dir|
+      adapter = double
+      allow(adapter).to receive(:send_message).and_raise("crash")
+      allow(adapter).to receive(:fetch_qr_code).and_return("qr")
+      allow(adapter).to receive(:connection_status).and_return({})
+      config = build_config(path: File.join(dir, "session.json"), adapter: adapter)
+      provider = described_class.new(configuration: config)
+
+      result = provider.deliver(to: "+1", body: "h")
+      expect(result).to be_failure
+      expect(result.error_code).to eq(:delivery_exception)
+    end
+  end
+
+  it "raises for missing adapter methods in scan" do
+    Dir.mktmpdir do |dir|
+      adapter = Object.new
+      config = build_config(path: File.join(dir, "session.json"), adapter: adapter)
+      provider = described_class.new(configuration: config)
+
+      expect { provider.scan_qr }.to raise_error(WhatsAppNotifier::ConfigurationError, /web_adapter/)
+    end
+  end
+
+  it "returns connection status via adapter" do
+    Dir.mktmpdir do |dir|
+      adapter = double(fetch_qr_code: "qr", connection_status: { state: "QR_REQUIRED", authenticated: false })
+      config = build_config(path: File.join(dir, "session.json"), adapter: adapter)
+      provider = described_class.new(configuration: config)
+
+      expect(provider.connection_status(metadata: { user_id: 1 })).to include(state: "QR_REQUIRED")
+    end
+  end
+
+  it "isolates sessions by metadata user_id" do
+    Dir.mktmpdir do |dir|
+      adapter = double(fetch_qr_code: "qr", connection_status: {})
+      allow(adapter).to receive(:send_message).and_return(
+        { success: true, session: { token: "user-a-token" } },
+        { success: true, session: { token: "user-b-token" } }
+      )
+      config = build_config(path: File.join(dir, "session.json"), adapter: adapter)
+      provider = described_class.new(configuration: config)
+
+      provider.deliver(to: "+1", body: "a", metadata: { user_id: "user-a" })
+      provider.deliver(to: "+2", body: "b", metadata: { user_id: "user-b" })
+
+      expect(adapter).to have_received(:send_message).with(payload: hash_including(metadata: { user_id: "user-a" }), session: {}).once
+      expect(adapter).to have_received(:send_message).with(payload: hash_including(metadata: { user_id: "user-b" }), session: {}).once
+    end
+  end
+end

data/spec/railtie_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+RSpec.describe "WhatsAppNotifier::Railtie" do
+  it "applies app config values to gem configuration" do
+    Object.send(:remove_const, :Rails) if defined?(Rails)
+    WhatsAppNotifier.send(:remove_const, :Railtie) if defined?(WhatsAppNotifier::Railtie)
+
+    stub_const("Rails", Module.new)
+
+    railtie_base = Class.new do
+      class << self
+        attr_accessor :captured_initializer
+      end
+
+      def self.config
+        @config ||= Struct.new(:whatsapp_notifier).new({})
+      end
+
+      def self.initializer(_name, &block)
+        self.captured_initializer = block
+      end
+    end
+    stub_const("Rails::Railtie", railtie_base)
+
+    load File.expand_path("../lib/whatsapp_notifier/railtie.rb", __dir__)
+
+    app_config = {
+      web_automation_enabled: true,
+      bulk_max_attempts: 5
+    }
+    app = Struct.new(:config).new(Struct.new(:whatsapp_notifier).new(app_config))
+    WhatsAppNotifier::Railtie.captured_initializer.call(app)
+
+    expect(WhatsAppNotifier.configuration.web_automation_enabled).to be(true)
+    expect(WhatsAppNotifier.configuration.bulk_max_attempts).to eq(5)
+  end
+end

data/spec/result_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+RSpec.describe WhatsAppNotifier::Result do
+  it "reports success and failure predicates" do
+    success_result = described_class.new(success: true, provider: :web_automation)
+    failure_result = described_class.new(success: false, provider: :web_automation)
+
+    expect(success_result).to be_success
+    expect(success_result).not_to be_failure
+    expect(failure_result).to be_failure
+  end
+end

data/spec/session/qr_service_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+RSpec.describe WhatsAppNotifier::Session::QrService do
+  it "fetches qr from adapter and persists it" do
+    Dir.mktmpdir do |dir|
+      store = WhatsAppNotifier::Session::Store.new(path: File.join(dir, "s.json"))
+      adapter = double(fetch_qr_code: "qr-1")
+      service = described_class.new(store: store, adapter: adapter)
+
+      expect(service.qr_code).to eq("qr-1")
+      expect(service.qr_code).to eq("qr-1")
+    end
+  end
+
+  it "caches qr code per user_id when metadata is provided" do
+    Dir.mktmpdir do |dir|
+      store = WhatsAppNotifier::Session::Store.new(path: File.join(dir, "s.json"))
+      adapter = double
+      allow(adapter).to receive(:fetch_qr_code).and_return("qr-user-1", "qr-user-2")
+      service = described_class.new(store: store, adapter: adapter)
+
+      expect(service.qr_code(metadata: { user_id: 1 })).to eq("qr-user-1")
+      expect(service.qr_code(metadata: { user_id: 1 })).to eq("qr-user-1")
+      expect(service.qr_code(metadata: { user_id: 2 })).to eq("qr-user-2")
+
+      expect(adapter).to have_received(:fetch_qr_code).twice
+    end
+  end
+
+  it "activates a session token" do
+    Dir.mktmpdir do |dir|
+      store = WhatsAppNotifier::Session::Store.new(path: File.join(dir, "s.json"))
+      adapter = double(fetch_qr_code: "qr-2")
+      service = described_class.new(store: store, adapter: adapter)
+      service.qr_code
+
+      service.activate!("tok")
+
+      expect(store.load).to include(active: true, token: "tok", qr_code: nil)
+    end
+  end
+end

data/spec/session/store_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+RSpec.describe WhatsAppNotifier::Session::Store do
+  it "returns empty hash when file is absent" do
+    Dir.mktmpdir do |dir|
+      store = described_class.new(path: File.join(dir, "missing.json"))
+      expect(store.load).to eq({})
+    end
+  end
+
+  it "saves and loads json data" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "session.json")
+      store = described_class.new(path: path)
+
+      store.save(active: true, token: "abc")
+
+      expect(store.load).to eq(active: true, token: "abc")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require "simplecov"
+
+SimpleCov.start do
+  add_filter "/spec/"
+  minimum_coverage 100
+end
+
+require "whatsapp_notifier"
+require "tmpdir"
+
+RSpec.configure do |config|
+  config.order = :random
+
+  config.before do
+    WhatsAppNotifier.reset!
+  end
+end

data/spec/web_adapter_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+require "json"
+
+RSpec.describe WhatsAppNotifier::WebAdapter do
+  let(:adapter) { described_class.new(base_url: "http://127.0.0.1:3001") }
+
+  def http_success(code: "200", body: {})
+    instance_double(Net::HTTPOK, body: JSON.generate(body), code: code, is_a?: true)
+  end
+
+  def http_failure(code: "500", body: "boom")
+    instance_double(Net::HTTPInternalServerError, body: body, code: code, is_a?: false)
+  end
+
+  it "sends a message using the service" do
+    response = http_success(body: { "success" => true })
+    allow(Net::HTTP).to receive(:start).and_return(response)
+
+    result = adapter.send_message(
+      payload: { to: "+1", body: "hi", metadata: { user_id: 1 }, idempotency_key: "k1" },
+      session: {}
+    )
+
+    expect(result).to include(success: true, message_id: "k1")
+  end
+
+  it "fetches qr and status data" do
+    qr_response = http_success(body: { "qr" => "data:image/png;base64,qr" })
+    status_response = http_success(body: { "state" => "AUTHENTICATED", "authenticated" => true, "hasQR" => false })
+    allow(Net::HTTP).to receive(:start).and_return(qr_response, status_response)
+
+    qr = adapter.fetch_qr_code(metadata: { user_id: "u-1" })
+    status = adapter.connection_status(metadata: { user_id: "u-1" })
+
+    expect(qr).to include("data:image")
+    expect(status).to include(state: "AUTHENTICATED", authenticated: true, has_qr: false)
+  end
+
+  it "raises for non-success service responses" do
+    allow(Net::HTTP).to receive(:start).and_return(http_failure(code: "422", body: JSON.generate({ error: "bad request" })))
+
+    expect do
+      adapter.fetch_qr_code(metadata: {})
+    end.to raise_error(/service request failed/)
+  end
+
+  it "handles empty and invalid response bodies gracefully" do
+    empty_body = instance_double(Net::HTTPOK, body: "", code: "200", is_a?: true)
+    invalid_body = instance_double(Net::HTTPInternalServerError, body: "raw-error", code: "500", is_a?: false)
+    allow(Net::HTTP).to receive(:start).and_return(empty_body, invalid_body)
+
+    expect(adapter.fetch_qr_code(metadata: {})).to be_nil
+    expect { adapter.connection_status(metadata: {}) }.to raise_error(/raw-error/)
+  end
+end

data/spec/whatsapp_notifier_spec.rb

@@ -0,0 +1,102 @@
+require "spec_helper"
+
+RSpec.describe WhatsAppNotifier do
+  it "configures and validates settings" do
+    described_class.configure do |config|
+      config.provider = :web_automation
+      config.web_automation_enabled = true
+      config.web_adapter = double(
+        send_message: { success: true, session: {} },
+        fetch_qr_code: "qr",
+        connection_status: { state: "AUTHENTICATED", authenticated: true }
+      )
+      config.bulk_max_recipients = 10
+      config.bulk_max_attempts = 2
+    end
+
+    expect(described_class.configuration.provider).to eq(:web_automation)
+  end
+
+  it "delegates single delivery to client" do
+    adapter = double
+    allow(adapter).to receive(:send_message).and_return(success: true, message_id: "m1", metadata: {}, session: {})
+    allow(adapter).to receive(:fetch_qr_code).and_return("qr")
+    allow(adapter).to receive(:connection_status).and_return(state: "AUTHENTICATED", authenticated: true)
+    described_class.configure do |config|
+      config.provider = :web_automation
+      config.web_automation_enabled = true
+      config.web_adapter = adapter
+    end
+
+    result = described_class.deliver(to: "+91", body: "hi", metadata: { a: 1 }, idempotency_key: "k1")
+
+    expect(result).to be_success
+    expect(result.message_id).to eq("m1")
+  end
+
+  it "delegates bulk delivery to client" do
+    described_class.configure do |config|
+      config.provider = :web_automation
+      config.web_automation_enabled = true
+      config.web_adapter = double(
+        send_message: { success: true, session: {} },
+        fetch_qr_code: "qr",
+        connection_status: { state: "AUTHENTICATED", authenticated: true }
+      )
+      config.bulk_base_delay_seconds = 0
+      config.bulk_jitter_seconds = 0
+    end
+
+    summary = described_class.deliver_bulk([{ to: "+1", body: "a" }], sleeper: ->(_seconds) {})
+
+    expect(summary[:total]).to eq(1)
+    expect(summary[:success]).to eq(1)
+  end
+
+  it "delegates qr scan through module API" do
+    Dir.mktmpdir do |dir|
+      described_class.configure do |config|
+        config.provider = :web_automation
+        config.web_automation_enabled = true
+        config.web_session_path = File.join(dir, "session.json")
+        config.web_adapter = double(
+          fetch_qr_code: "qr-via-module",
+          send_message: { success: true, session: {} },
+          connection_status: { state: "QR_REQUIRED", authenticated: false }
+        )
+      end
+
+      expect(described_class.scan_qr).to eq("qr-via-module")
+    end
+  end
+
+  it "delegates status through module API" do
+    described_class.configure do |config|
+      config.provider = :web_automation
+      config.web_automation_enabled = true
+      config.web_adapter = double(
+        fetch_qr_code: "qr-via-module",
+        send_message: { success: true, session: {} },
+        connection_status: { state: "AUTHENTICATED", authenticated: true }
+      )
+    end
+
+    expect(described_class.connection_status).to include(state: "AUTHENTICATED", authenticated: true)
+  end
+
+  it "exposes bundled service path" do
+    expect(File.directory?(described_class.service_path)).to be(true)
+  end
+
+  it "delegates module helpers to client" do
+    fake_client = double
+    allow(fake_client).to receive(:deliver_bulk).and_return(total: 0, success: 0, failed: 0, results: [])
+    allow(fake_client).to receive(:scan_qr).and_return("qr-code")
+    allow(fake_client).to receive(:connection_status).and_return(state: "QR_REQUIRED")
+    described_class.instance_variable_set(:@client, fake_client)
+
+    expect(described_class.deliver_bulk([], provider: :web_automation)[:total]).to eq(0)
+    expect(described_class.scan_qr(provider: :web_automation, metadata: { user_id: 1 })).to eq("qr-code")
+    expect(described_class.connection_status(provider: :web_automation, metadata: { user_id: 1 })).to include(state: "QR_REQUIRED")
+  end
+end