pushover 3.0.2 → 4.0.0

data/spec/pushover/messages_spec.rb

@@ -0,0 +1,199 @@
+require 'base64'
+require 'spec_helper'
+
+describe Pushover::Messages do
+  subject(:messages) { Pushover::Client.new(token: 'app-token').messages }
+
+  after { Excon.stubs.clear }
+
+  describe '#create' do
+    context 'with a valid message' do
+      let(:request) { {} }
+      let(:response) { messages.create(user: 'user-key', message: 'Hello', title: 'Greeting', html: true) }
+
+      before do
+        captured_request = request
+        Excon.stub(method: :post, path: '/1/messages.json') do |params|
+          captured_request.replace(params)
+          { body: Oj.dump(status: 1, request: 'request-id'), headers: { 'X-Limit-App-Remaining' => '9' }, status: 200 }
+        end
+      end
+
+      it 'posts all fields as JSON' do
+        response
+
+        expect(Oj.strict_load(request[:body])).to eq(
+          'token' => 'app-token', 'user' => 'user-key', 'message' => 'Hello', 'title' => 'Greeting', 'html' => 1
+        )
+      end
+
+      it 'uses the JSON content type' do
+        response
+
+        expect(request[:headers]).to include('Content-Type' => 'application/json')
+      end
+
+      it 'returns a response' do
+        expect(response).to have_attributes(status: 1, request: 'request-id')
+      end
+
+      it 'preserves response headers' do
+        expect(response.headers).to include('X-Limit-App-Remaining' => '9')
+      end
+    end
+
+    it 'returns Pushover errors from a 4xx response' do
+      Excon.stub(method: :post, path: '/1/messages.json') do |_params|
+        { body: Oj.dump(status: 0, errors: ['user identifier is invalid']), status: 400 }
+      end
+
+      response = messages.create(user: 'invalid', message: 'Hello')
+
+      expect(response).to have_attributes(status: 0, errors: ['user identifier is invalid'])
+    end
+
+    def stub_success
+      Excon.stub(
+        { method: :post, path: '/1/messages.json' },
+        { body: Oj.dump(status: 1, request: 'request-id'), status: 200 }
+      )
+    end
+
+    %i[user message].each do |parameter|
+      it "requires #{parameter}" do
+        params = { user: 'user-key', message: 'Hello' }
+        params[parameter] = ''
+
+        expect { messages.create(**params) }.to raise_error ArgumentError, /#{parameter} must be supplied/
+      end
+    end
+
+    {
+      message:   1024,
+      title:     250,
+      url:       512,
+      url_title: 100
+    }.each do |parameter, maximum|
+      it "limits #{parameter} to #{maximum} characters" do
+        params = { user: 'user-key', message: 'Hello', parameter => 'a' * (maximum + 1) }
+
+        expect { messages.create(**params) }.to raise_error ArgumentError, /#{parameter} must be at most #{maximum} characters/
+      end
+    end
+
+    it 'limits one request to 50 users' do
+      users = Array.new(51, 'user-key').join(',')
+
+      expect { messages.create(user: users, message: 'Hello') }.to raise_error ArgumentError, /at most 50 users/
+    end
+
+    it 'validates device names' do
+      expect do
+        messages.create(user: 'user-key', message: 'Hello', device: 'not a valid device')
+      end.to raise_error ArgumentError, /device contains an invalid name/
+    end
+
+    it 'accepts only documented priorities' do
+      expect do
+        messages.create(user: 'user-key', message: 'Hello', priority: 3)
+      end.to raise_error ArgumentError, /priority must be one of/
+    end
+
+    it 'requires retry and expire for emergency priority' do
+      expect do
+        messages.create(user: 'user-key', message: 'Hello', priority: 2)
+      end.to raise_error ArgumentError, /retry and expire must be supplied/
+    end
+
+    it 'requires emergency retries of at least 30 seconds' do
+      expect do
+        messages.create(user: 'user-key', message: 'Hello', priority: 2, retry: 29, expire: 10_801)
+      end.to raise_error ArgumentError, /retry must be at least 30 seconds/
+    end
+
+    it 'limits emergency expiration to 10800 seconds' do
+      expect do
+        messages.create(user: 'user-key', message: 'Hello', priority: 2, retry: 30, expire: 10_801)
+      end.to raise_error ArgumentError, /expire must be at most 10800 seconds/
+    end
+
+    it 'rejects emergency-only fields for other priorities' do
+      expect do
+        messages.create(user: 'user-key', message: 'Hello', callback: 'https://example.test/callback')
+      end.to raise_error ArgumentError, /callback is only valid with priority 2/
+    end
+
+    it 'requires an HTTP or HTTPS callback URL' do
+      expect do
+        messages.create(user: 'user-key', message: 'Hello', priority: 2, retry: 30, expire: 60, callback: 'file:///tmp/callback')
+      end.to raise_error ArgumentError, /callback must be an HTTP or HTTPS URL/
+    end
+
+    it 'rejects a malformed callback URL' do
+      expect do
+        messages.create(user: 'user-key', message: 'Hello', priority: 2, retry: 30, expire: 60, callback: 'http://[')
+      end.to raise_error ArgumentError, /callback must be an HTTP or HTTPS URL/
+    end
+
+    it 'does not allow HTML and monospace formatting together' do
+      expect do
+        messages.create(user: 'user-key', message: 'Hello', html: true, monospace: true)
+      end.to raise_error ArgumentError, /html and monospace cannot both be enabled/
+    end
+
+    it 'requires a positive TTL' do
+      expect do
+        messages.create(user: 'user-key', message: 'Hello', ttl: 0)
+      end.to raise_error ArgumentError, /ttl must be a positive integer/
+    end
+
+    it 'requires valid Base64 attachment data' do
+      expect do
+        messages.create(user: 'user-key', message: 'Hello', attachment_base64: 'not-base64', attachment_type: 'image/png')
+      end.to raise_error ArgumentError, /attachment_base64 must be valid Base64/
+    end
+
+    it 'limits decoded attachments to 5 MiB' do
+      oversized = Base64.strict_encode64('a' * 5_242_881)
+
+      expect do
+        messages.create(user: 'user-key', message: 'Hello', attachment_base64: oversized, attachment_type: 'image/png')
+      end.to raise_error ArgumentError, /attachment must not exceed 5242880 bytes/
+    end
+
+    it 'requires attachment data and MIME type together' do
+      expect do
+        messages.create(user: 'user-key', message: 'Hello', attachment_base64: Base64.strict_encode64('image'))
+      end.to raise_error ArgumentError, /attachment_type must be supplied/
+    end
+
+    context 'with end-to-end encryption' do
+      let(:request) { {} }
+      let(:key) { '00' * 32 }
+
+      before do
+        captured_request = request
+        allow(SecureRandom).to receive(:random_bytes).and_return("\x01" * 16)
+        Excon.stub(method: :post, path: '/1/messages.json') do |params|
+          captured_request.replace(Oj.strict_load(params[:body]))
+          { body: Oj.dump(status: 1, request: 'request-id'), status: 200 }
+        end
+        messages.create(user: 'user-key', message: 'secret', title: 'private', encryption_key: key)
+      end
+
+      it 'uses the documented deterministic wire format' do
+        expect(request.slice('encrypted', 'message', 'title')).to eq(
+          'encrypted' => 1,
+          'message'   => 'AQEBAQEBAQEBAQEBAQEBAU0FqlkYIHEPzHs0NklFY9QT8ZekMQAM/J6iku1rmOJcEcm1SgT5ASVxoQW5SUFLnyWhe0y1Tp7q0YmS2iTpk4k=',
+          'title'     => 'AQEBAQEBAQEBAQEBAQEBAWWaD5zPUESFUncs7Hm+DBMTqpHx+n5zEHeQcvJiY+/LX/xd2rJVGXcosjBT23uEQ1TagEXt9wehyXozQxxYguw='
+        )
+      end
+    end
+
+    it 'requires a 64-character hexadecimal encryption key' do
+      expect do
+        messages.create(user: 'user-key', message: 'Hello', encryption_key: 'invalid')
+      end.to raise_error ArgumentError, /encryption_key must be 64 hexadecimal characters/
+    end
+  end
+end

data/spec/pushover/receipt_spec.rb

@@ -1,24 +1,132 @@
+require 'open3'
+require 'rbconfig'
 require 'spec_helper'
 
 describe Pushover::Receipt do
-  it { is_expected.to have_attributes(receipt: a_kind_of(String).or(be_nil)) }
-  it { is_expected.to have_attributes(token: a_kind_of(String).or(be_nil)) }
+  subject(:legacy_receipt) { described_class.new(receipt: receipt, token: token) }
 
-  it { is_expected.to respond_to(:get).with(0).argument }
+  let(:receipt) { 'r' * 30 }
+  let(:token) { 'app-token' }
+  let(:standalone_script) do
+    <<~'RUBY'
+      require 'excon'
+      Excon.defaults[:mock] = true
+      require 'pushover/receipt'
+      receipt = 'r' * 30
+      Excon.stub(method: :get, path: "/1/receipts/#{receipt}.json", query: { token: 'app-token' }) do
+        { body: Oj.dump('status' => 1), status: 200 }
+      end
+      abort unless Pushover::Receipt.new(token: 'app-token', receipt: receipt).get.status == 1
+    RUBY
+  end
+
+  after { Excon.stubs.clear }
+
+  it 'supports the standalone legacy require path' do
+    _stdout, stderr, status = Open3.capture3(RbConfig.ruby, '-Ilib', '-e', standalone_script)
+
+    expect(status).to be_success, stderr
+  end
+
+  it 'uses an explicit compatibility class' do
+    expect(described_class.superclass).to eq(Object)
+  end
+
+  it 'accepts the legacy keyword form' do
+    instance = described_class.new(receipt: receipt, token: token)
+
+    expect(instance).to have_attributes(receipt: receipt, token: token)
+  end
+
+  it 'accepts a single Hash with string keys' do
+    instance = described_class.new('receipt' => receipt, 'token' => token)
+
+    expect(instance).to have_attributes(receipt: receipt, token: token)
+  end
+
+  it 'keeps the legacy members writable' do
+    legacy_receipt.receipt = 'a' * 30
 
-  describe "#push" do
-    let(:params) { { 'token' => 't', 'receipt' => 'receipt' } }
+    expect(legacy_receipt.receipt).to eq('a' * 30)
+  end
+
+  it 'rejects unknown members' do
+    expect { described_class.new(unknown: 'value') }.to raise_error ArgumentError
+  end
 
-    it "is expected to send" do
-      expect { described_class.new(params).get }.to raise_error Excon::Error::StubNotFound
+  it 'rejects non-Hash positional attributes' do
+    [nil, false, 1, 'invalid'].each do |attributes|
+      expect { described_class.new(attributes) }.to raise_error ArgumentError, /attributes must be supplied as a Hash/
     end
+  end
+
+  it { is_expected.to respond_to(:get).with(0).arguments }
 
-    ['token', 'receipt'].each do |param|
-      context "when #{param} is not supplied" do
-        before { params.delete param }
+  describe '#get' do
+    before { allow(Warning).to receive(:warn) }
 
-        it { expect { described_class.new(params).get }.to raise_error RuntimeError, /#{param} must be supplied/ }
+    context 'with a valid receipt' do
+      let(:request) { {} }
+      let(:response) { legacy_receipt.get }
+
+      before do
+        captured_request = request
+        Excon.stub(
+          method: :get,
+          path:   "/1/receipts/#{receipt}.json",
+          query:  { token: token },
+          body:   nil
+        ) do |request_params|
+          captured_request.replace(request_params)
+          {
+            body:    Oj.dump('status' => 1, 'request' => 'request-id', 'acknowledged' => 0),
+            headers: { 'X-Limit-App-Remaining' => '9' },
+            status:  200
+          }
+        end
+      end
+
+      it 'delegates to the shared receipt endpoint' do
+        response
+
+        expect(request.slice(:method, :path, :query)).to eq(
+          method: :get, path: "/1/receipts/#{receipt}.json", query: "token=#{token}"
+        )
+      end
+
+      it 'does not send a request body' do
+        response
+
+        expect(request).not_to have_key(:body)
       end
+
+      it 'returns the shared response' do
+        expect(response).to have_attributes(status: 1, request: 'request-id', attributes: { 'acknowledged' => 0 })
+      end
+
+      it 'emits the exact migration warning once' do
+        response
+
+        expect(Warning).to have_received(:warn).with(
+          a_string_including('Pushover::Receipt#get is deprecated; use Pushover::Client.new(token: ...).receipts.get(receipt: ...)'),
+          category: nil
+        ).once
+      end
+    end
+
+    %i[receipt token].each do |parameter|
+      it "preserves the legacy missing-#{parameter} error" do
+        instance = described_class.new(receipt: receipt, token: token)
+        instance.public_send("#{parameter}=", nil)
+
+        expect { instance.get }.to raise_error RuntimeError, "#{parameter} must be supplied"
+      end
+    end
+
+    it 'applies current receipt validation after the legacy presence checks' do
+      instance = described_class.new(receipt: 'receipt', token: token)
+
+      expect { instance.get }.to raise_error ArgumentError, /receipt must be 30 alphanumeric characters/
     end
   end
 end

data/spec/pushover/receipts_spec.rb

@@ -0,0 +1,232 @@
+require 'spec_helper'
+
+describe Pushover::Receipts do
+  subject(:receipts) { Pushover::Client.new(token: 'app-token').receipts }
+
+  let(:receipt) { 'a' * 30 }
+  let(:receipt_attributes) do
+    {
+      'acknowledged'           => 1,
+      'acknowledged_at'        => 1_723_990_000,
+      'acknowledged_by'        => 'user-key',
+      'acknowledged_by_device' => 'phone',
+      'last_delivered_at'      => 1_723_989_900,
+      'expired'                => 0,
+      'expires_at'             => 1_723_993_600,
+      'called_back'            => 1,
+      'called_back_at'         => 1_723_990_001
+    }
+  end
+  let(:success_body) { { 'status' => 1, 'request' => 'request-id' }.merge(receipt_attributes) }
+
+  after { Excon.stubs.clear }
+
+  describe '#get' do
+    context 'with a valid receipt' do
+      let(:request) { {} }
+      let(:response) { receipts.get(receipt: receipt) }
+
+      before do
+        captured_request = request
+        Excon.stub(
+          method: :get,
+          path:   "/1/receipts/#{receipt}.json",
+          query:  { token: 'app-token' },
+          body:   nil
+        ) do |params|
+          captured_request.replace(params)
+          {
+            body:    Oj.dump(success_body),
+            headers: { 'X-Limit-App-Remaining' => '9' },
+            status:  200
+          }
+        end
+      end
+
+      it 'gets the receipt with the application token in the query string' do
+        response
+
+        expect(request.slice(:method, :path, :query)).to eq(method: :get, path: "/1/receipts/#{receipt}.json", query: 'token=app-token')
+      end
+
+      it 'does not send a request body' do
+        response
+
+        expect(request).not_to have_key(:body)
+      end
+
+      it 'returns the response metadata' do
+        expect(response).to have_attributes(status: 1, request: 'request-id')
+      end
+
+      it 'returns the receipt status fields' do
+        expect(response.attributes).to eq(receipt_attributes)
+      end
+
+      it 'preserves response headers' do
+        expect(response.headers).to include('X-Limit-App-Remaining' => '9')
+      end
+    end
+
+    context 'when Pushover rejects the request' do
+      before do
+        Excon.stub(
+          { method: :get, path: "/1/receipts/#{receipt}.json", query: { token: 'app-token' }, body: nil },
+          { body: Oj.dump('status' => 0, 'errors' => ['receipt is invalid']), status: 400 }
+        )
+      end
+
+      it 'returns errors from a 4xx response' do
+        response = receipts.get(receipt: receipt)
+
+        expect(response).to have_attributes(status: 0, errors: ['receipt is invalid'])
+      end
+    end
+
+    it 'requires a receipt' do
+      expect { receipts.get(receipt: '') }.to raise_error ArgumentError, /receipt must be supplied/
+    end
+
+    ['a' * 29, 'a' * 31, "#{'a' * 29}-"].each do |invalid_receipt|
+      it 'requires exactly 30 alphanumeric characters' do
+        expect { receipts.get(receipt: invalid_receipt) }
+          .to raise_error ArgumentError, /receipt must be 30 alphanumeric characters/
+      end
+    end
+  end
+
+  describe '#cancel' do
+    context 'with a valid receipt' do
+      let(:request) { {} }
+      let(:response) { receipts.cancel(receipt: receipt) }
+
+      before do
+        captured_request = request
+        Excon.stub(method: :post, path: "/1/receipts/#{receipt}/cancel.json") do |params|
+          captured_request.replace(params)
+          {
+            body:    Oj.dump(status: 1, request: 'request-id'),
+            headers: { 'X-Limit-App-Remaining' => '9' },
+            status:  200
+          }
+        end
+      end
+
+      it 'posts to the receipt cancellation endpoint' do
+        response
+
+        expect(request.slice(:method, :path)).to eq(method: :post, path: "/1/receipts/#{receipt}/cancel.json")
+      end
+
+      it 'sends the application token as JSON' do
+        response
+
+        expect(Oj.strict_load(request[:body])).to eq('token' => 'app-token')
+      end
+
+      it 'uses the JSON content type' do
+        response
+
+        expect(request[:headers]).to include('Content-Type' => 'application/json')
+      end
+
+      it 'returns the response metadata' do
+        expect(response).to have_attributes(status: 1, request: 'request-id')
+      end
+
+      it 'preserves response headers' do
+        expect(response.headers).to include('X-Limit-App-Remaining' => '9')
+      end
+    end
+
+    context 'when Pushover rejects the request' do
+      before do
+        Excon.stub(method: :post, path: "/1/receipts/#{receipt}/cancel.json") do |_params|
+          { body: Oj.dump(status: 0, errors: ['receipt is invalid']), status: 400 }
+        end
+      end
+
+      it 'returns errors from a 4xx response' do
+        response = receipts.cancel(receipt: receipt)
+
+        expect(response).to have_attributes(status: 0, errors: ['receipt is invalid'])
+      end
+    end
+
+    it 'requires a receipt' do
+      expect { receipts.cancel(receipt: '') }.to raise_error ArgumentError, /receipt must be supplied/
+    end
+
+    ['a' * 29, 'a' * 31, "#{'a' * 29}-"].each do |invalid_receipt|
+      it 'requires exactly 30 alphanumeric characters' do
+        expect { receipts.cancel(receipt: invalid_receipt) }
+          .to raise_error ArgumentError, /receipt must be 30 alphanumeric characters/
+      end
+    end
+  end
+
+  describe '#cancel_by_tag' do
+    context 'with a valid tag' do
+      let(:request) { {} }
+      let(:response) { receipts.cancel_by_tag(tag: 'l=chicago/ops room') }
+
+      before do
+        captured_request = request
+        Excon.stub(method: :post, path: '/1/receipts/cancel_by_tag/l%3Dchicago%2Fops%20room.json') do |params|
+          captured_request.replace(params)
+          {
+            body:    Oj.dump(status: 1, request: 'request-id'),
+            headers: { 'X-Limit-App-Remaining' => '9' },
+            status:  200
+          }
+        end
+      end
+
+      it 'posts with the tag encoded as one path segment' do
+        response
+
+        expect(request.slice(:method, :path)).to eq(
+          method: :post, path: '/1/receipts/cancel_by_tag/l%3Dchicago%2Fops%20room.json'
+        )
+      end
+
+      it 'sends the application token as JSON' do
+        response
+
+        expect(Oj.strict_load(request[:body])).to eq('token' => 'app-token')
+      end
+
+      it 'uses the JSON content type' do
+        response
+
+        expect(request[:headers]).to include('Content-Type' => 'application/json')
+      end
+
+      it 'returns the response metadata' do
+        expect(response).to have_attributes(status: 1, request: 'request-id')
+      end
+
+      it 'preserves response headers' do
+        expect(response.headers).to include('X-Limit-App-Remaining' => '9')
+      end
+    end
+
+    context 'when Pushover rejects the request' do
+      before do
+        Excon.stub(method: :post, path: '/1/receipts/cancel_by_tag/l%3Dchicago%2Fops%20room.json') do |_params|
+          { body: Oj.dump(status: 0, errors: ['tag is invalid']), status: 400 }
+        end
+      end
+
+      it 'returns errors from a 4xx response' do
+        response = receipts.cancel_by_tag(tag: 'l=chicago/ops room')
+
+        expect(response).to have_attributes(status: 0, errors: ['tag is invalid'])
+      end
+    end
+
+    it 'requires a tag' do
+      expect { receipts.cancel_by_tag(tag: '') }.to raise_error ArgumentError, /tag must be supplied/
+    end
+  end
+end

data/spec/pushover/response_spec.rb

@@ -1,26 +1,31 @@
 require 'spec_helper'
 
-describe Pushover do
-  describe Pushover::Response do
-    let(:excon_response) { Excon::Response.new body: '{}', headers: {} }
+describe Pushover::Response do
+  let(:excon_response) { Excon::Response.new body: '{}', headers: {} }
 
-    it { is_expected.to have_attributes(status: a_kind_of(String).or(be_nil)) }
-    it { is_expected.to have_attributes(request: a_kind_of(String).or(be_nil)) }
-    it { is_expected.to have_attributes(errors: a_kind_of(Array).or(be_nil)) }
-    it { is_expected.to have_attributes(receipt: a_kind_of(String).or(be_nil)) }
-    it { is_expected.to have_attributes(headers: a_kind_of(Hash).or(be_nil)) }
-    it { is_expected.to have_attributes(attributes: a_kind_of(Hash).or(be_nil)) }
+  it { is_expected.to have_attributes(status: a_kind_of(String).or(be_nil)) }
+  it { is_expected.to have_attributes(request: a_kind_of(String).or(be_nil)) }
+  it { is_expected.to have_attributes(errors: a_kind_of(Array).or(a_kind_of(Hash)).or(be_nil)) }
+  it { is_expected.to have_attributes(receipt: a_kind_of(String).or(be_nil)) }
+  it { is_expected.to have_attributes(headers: a_kind_of(Hash).or(be_nil)) }
+  it { is_expected.to have_attributes(attributes: a_kind_of(Hash).or(be_nil)) }
 
-    it { expect(described_class).to respond_to(:create_from_excon_response).with(1).argument }
+  it { expect(described_class).to respond_to(:create_from_excon_response).with(1).argument }
 
-    describe "#to_s" do
-      it "is expected to be purty." do
-        expect(Pushover::Response.create_from_excon_response(excon_response).to_s).to include('status')
-      end
+  describe "#to_s" do
+    it "is expected to be purty." do
+      expect(described_class.create_from_excon_response(excon_response).to_s).to include('status')
     end
 
-    describe "::create_from_excon_response" do
-      it { expect(Pushover::Response.create_from_excon_response(excon_response)).to be_a_kind_of described_class }
+    it 'formats structured errors' do
+      excon_response.body = Oj.dump('status' => 0, 'errors' => { 'token' => ['has no license credits'] })
+
+      expect(described_class.create_from_excon_response(excon_response).to_s)
+        .to include('errors: {"token"=>["has no license credits"]}')
     end
   end
+
+  describe "::create_from_excon_response" do
+    it { expect(described_class.create_from_excon_response(excon_response)).to be_a described_class }
+  end
 end