pushover 3.0.2 → 4.0.0

data/spec/pushover/licenses_spec.rb

@@ -0,0 +1,238 @@
+require 'spec_helper'
+
+describe Pushover::Licenses do
+  subject(:licenses) { Pushover::Client.new(token: 'app-token').licenses }
+
+  let(:user) { 'u' * 30 }
+
+  after { Excon.stubs.clear }
+
+  describe '#get' do
+    context 'when Pushover returns available license credits' do
+      let(:request) { {} }
+      let(:response) { licenses.get }
+
+      before do
+        captured_request = request
+        Excon.stub(
+          method: :get,
+          path:   '/1/licenses.json',
+          query:  { token: 'app-token' },
+          body:   nil
+        ) do |params|
+          captured_request.replace(params)
+          {
+            body:    Oj.dump('status' => 1, 'request' => 'request-id', 'credits' => 5),
+            headers: { 'X-Request-Id' => 'header-id' },
+            status:  200
+          }
+        end
+      end
+
+      it 'gets credits with the application token in the query string' do
+        response
+
+        expect(request.slice(:method, :path, :query)).to eq(
+          method: :get, path: '/1/licenses.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 response metadata and available credits' do
+        expect(response).to have_attributes(
+          status: 1, request: 'request-id', attributes: { 'credits' => 5 }
+        )
+      end
+
+      it 'preserves response headers' do
+        expect(response.headers).to include('X-Request-Id' => 'header-id')
+      end
+    end
+
+    context 'when Pushover rejects the application token' do
+      before do
+        Excon.stub(
+          { method: :get, path: '/1/licenses.json', query: { token: 'app-token' }, body: nil },
+          {
+            body:   Oj.dump(
+              'status'  => 0,
+              'request' => 'request-id',
+              'errors'  => { 'token' => ['is invalid'] }
+            ),
+            status: 400
+          }
+        )
+      end
+
+      it 'preserves structured licensing errors' do
+        expect(licenses.get).to have_attributes(
+          status: 0, request: 'request-id', errors: { 'token' => ['is invalid'] }
+        )
+      end
+    end
+  end
+
+  describe '#assign' do
+    context 'with a user key and operating system' do
+      let(:request) { {} }
+      let(:response) { licenses.assign(user: user, os: 'Android') }
+
+      before do
+        captured_request = request
+        Excon.stub(method: :post, path: '/1/licenses/assign.json') do |params|
+          captured_request.replace(params)
+          {
+            body:    Oj.dump('status' => 1, 'request' => 'request-id', 'credits' => 4),
+            headers: { 'X-Request-Id' => 'header-id' },
+            status:  200
+          }
+        end
+      end
+
+      it 'posts one non-idempotent request to the assignment endpoint' do
+        response
+
+        expect(request.slice(:method, :path, :idempotent)).to eq(
+          method: :post, path: '/1/licenses/assign.json', idempotent: false
+        )
+      end
+
+      it 'serializes the application token and assignment fields with string keys' do
+        response
+
+        expect(Oj.strict_load(request[:body])).to eq(
+          'token' => 'app-token', 'user' => user, 'os' => 'Android'
+        )
+      end
+
+      it 'uses the JSON content type' do
+        response
+
+        expect(request[:headers]).to include('Content-Type' => 'application/json')
+      end
+
+      it 'returns response metadata, remaining credits, and headers' do
+        expect(response).to have_attributes(
+          status: 1, request: 'request-id', attributes: { 'credits' => 4 }, headers: include('X-Request-Id' => 'header-id')
+        )
+      end
+    end
+
+    context 'with an email address' do
+      let(:request) { {} }
+
+      before do
+        captured_request = request
+        Excon.stub(method: :post, path: '/1/licenses/assign.json') do |params|
+          captured_request.replace(params)
+          { body: Oj.dump('status' => 1, 'request' => 'request-id', 'credits' => 4), status: 200 }
+        end
+
+        licenses.assign(email: 'person@example.test')
+      end
+
+      it 'omits the user and operating system fields' do
+        expect(Oj.strict_load(request[:body])).to eq(
+          'token' => 'app-token', 'email' => 'person@example.test'
+        )
+      end
+    end
+
+    context 'with both recipient identifiers' do
+      let(:request) { {} }
+
+      before do
+        captured_request = request
+        Excon.stub(method: :post, path: '/1/licenses/assign.json') do |params|
+          captured_request.replace(params)
+          { body: Oj.dump('status' => 1, 'request' => 'request-id', 'credits' => 4), status: 200 }
+        end
+
+        licenses.assign(user: user, email: 'person@example.test')
+      end
+
+      it 'does not invent a mutual-exclusion rule' do
+        expect(Oj.strict_load(request[:body])).to include(
+          'user' => user, 'email' => 'person@example.test'
+        )
+      end
+    end
+
+    context 'with a blank operating system' do
+      let(:request) { {} }
+
+      before do
+        captured_request = request
+        Excon.stub(method: :post, path: '/1/licenses/assign.json') do |params|
+          captured_request.replace(params)
+          { body: Oj.dump('status' => 1, 'request' => 'request-id', 'credits' => 4), status: 200 }
+        end
+
+        licenses.assign(user: user, os: '')
+      end
+
+      it 'preserves the documented first-platform selection' do
+        expect(Oj.strict_load(request[:body])).to include('os' => '')
+      end
+    end
+
+    context 'when Pushover rejects the assignment' do
+      before do
+        Excon.stub(
+          { method: :post, path: '/1/licenses/assign.json' },
+          {
+            body:   Oj.dump(
+              'status'  => 0,
+              'request' => 'request-id',
+              'errors'  => { 'token' => ['is out of available license credits'] }
+            ),
+            status: 400
+          }
+        )
+      end
+
+      it 'returns structured errors without retrying or flattening them' do
+        expect(licenses.assign(user: user)).to have_attributes(
+          status:  0,
+          request: 'request-id',
+          errors:  { 'token' => ['is out of available license credits'] }
+        )
+      end
+    end
+
+    it 'requires a user key or email address' do
+      expect { licenses.assign }.to raise_error ArgumentError, /user or email must be supplied/
+    end
+
+    it 'validates a supplied blank user key' do
+      expect { licenses.assign(user: '', email: 'person@example.test') }
+        .to raise_error ArgumentError, /user must be supplied/
+    end
+
+    ['u' * 29, 'u' * 31, "#{'u' * 29}-", 123].each do |invalid_user|
+      it 'requires a 30-character alphanumeric user key' do
+        expect { licenses.assign(user: invalid_user) }
+          .to raise_error ArgumentError, /user must be 30 alphanumeric characters/
+      end
+    end
+
+    ['', '   ', 123].each do |invalid_email|
+      it 'requires a supplied email address to be a nonblank string' do
+        expect { licenses.assign(email: invalid_email) }
+          .to raise_error ArgumentError, /email must be a nonblank String/
+      end
+    end
+
+    ['android', 'IOS', 'Windows', 123].each do |invalid_os|
+      it 'accepts only documented operating systems' do
+        expect { licenses.assign(user: user, os: invalid_os) }
+          .to raise_error ArgumentError, /os must be blank, Android, iOS, or Desktop/
+      end
+    end
+  end
+end

data/spec/pushover/limits_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe Pushover::Limits do
+  subject(:limits) { Pushover::Client.new(token: 'app-token').limits }
+
+  let(:usage_limits) do
+    {
+      'limit'     => 10_000,
+      'remaining' => 7_496,
+      'reset'     => 1_393_653_600
+    }
+  end
+
+  after { Excon.stubs.clear }
+
+  describe '#get' do
+    context 'when Pushover returns account usage limits' do
+      let(:request) { {} }
+      let(:response) { limits.get }
+
+      before do
+        captured_request = request
+        Excon.stub(
+          method: :get,
+          path:   '/1/apps/limits.json',
+          query:  { token: 'app-token' },
+          body:   nil
+        ) do |params|
+          captured_request.replace(params)
+          {
+            body:    Oj.dump({ 'status' => 1, 'request' => 'request-id' }.merge(usage_limits)),
+            headers: { 'X-Limit-App-Remaining' => '7496' },
+            status:  200
+          }
+        end
+      end
+
+      it 'gets limits with the application token in the query string' do
+        response
+
+        expect(request.slice(:method, :path, :query)).to eq(
+          method: :get, path: '/1/apps/limits.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 response metadata' do
+        expect(response).to have_attributes(status: 1, request: 'request-id')
+      end
+
+      it 'returns the account usage limit, remaining messages, and reset time' do
+        expect(response.attributes).to eq(usage_limits)
+      end
+
+      it 'preserves response headers' do
+        expect(response.headers).to include('X-Limit-App-Remaining' => '7496')
+      end
+    end
+
+    context 'when Pushover rejects the application token' do
+      before do
+        Excon.stub(
+          { method: :get, path: '/1/apps/limits.json', query: { token: 'app-token' }, body: nil },
+          {
+            body:   Oj.dump(
+              'status'  => 0,
+              'request' => 'request-id',
+              'errors'  => ['application token is invalid'],
+              'token'   => 'invalid'
+            ),
+            status: 400
+          }
+        )
+      end
+
+      it 'returns errors from a 4xx response' do
+        response = limits.get
+
+        expect(response).to have_attributes(status: 0, errors: ['application token is invalid'])
+      end
+
+      it 'preserves endpoint-specific error details' do
+        expect(limits.get.attributes).to eq('token' => 'invalid')
+      end
+    end
+  end
+end

data/spec/pushover/message_spec.rb

@@ -1,35 +1,155 @@
+require 'open3'
+require 'rbconfig'
 require 'spec_helper'
 
 describe Pushover::Message do
-  it { is_expected.to have_attributes(token: a_kind_of(String).or(be_nil)) }
-  it { is_expected.to have_attributes(user: a_kind_of(String).or(be_nil)) }
-  it { is_expected.to have_attributes(message: a_kind_of(String).or(be_nil)) }
-  it { is_expected.to have_attributes(attachment: a_kind_of(String).or(be_nil)) }
-  it { is_expected.to have_attributes(device: a_kind_of(String).or(be_nil)) }
-  it { is_expected.to have_attributes(title: a_kind_of(String).or(be_nil)) }
-  it { is_expected.to have_attributes(url: a_kind_of(String).or(be_nil)) }
-  it { is_expected.to have_attributes(url_title: a_kind_of(String).or(be_nil)) }
-  it { is_expected.to have_attributes(priority: a_kind_of(Numeric).or(be_nil)) }
-  it { is_expected.to have_attributes(sound: a_kind_of(String).or(be_nil)) }
-  it { is_expected.to have_attributes(timestamp: a_kind_of(DateTime).or(be_nil)) }
-  it { is_expected.to have_attributes(expire: a_kind_of(Numeric).or(be_nil)) }
-  it { is_expected.to have_attributes(retry: a_kind_of(Numeric).or(be_nil)) }
-  it { is_expected.to have_attributes(callback: a_kind_of(String).or(be_nil)) }
-
-  it { is_expected.to respond_to(:push).with(0).argument }
-
-  describe "#push" do
-    let(:params) { { 'token' => 't', 'user' => 'u', 'message' => 'message' } }
-
-    it "is expected to send" do
-      expect { described_class.new(params).push }.to raise_error Excon::Error::StubNotFound
+  subject(:legacy_message) { described_class.new(params) }
+
+  let(:params) { { token: 'app-token', user: 'user-key', message: 'Hello' } }
+  let(:standalone_script) do
+    <<~RUBY
+      require 'excon'
+      Excon.defaults[:mock] = true
+      require 'pushover/message'
+      Excon.stub(method: :post, path: '/1/messages.json') { { body: Oj.dump('status' => 1), status: 200 } }
+      abort unless Pushover::Message.new(token: 'app-token', user: 'user-key', message: 'Hello').push.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
+    message = described_class.new(token: 'app-token', user: 'user-key', message: 'Hello')
+
+    expect(message).to have_attributes(token: 'app-token', user: 'user-key', message: 'Hello')
+  end
+
+  it 'accepts a single Hash with string keys' do
+    message = described_class.new('token' => 'app-token', 'user' => 'user-key', 'message' => 'Hello')
+
+    expect(message).to have_attributes(token: 'app-token', user: 'user-key', message: 'Hello')
+  end
+
+  it 'keeps the legacy members writable' do
+    legacy_message.title = 'Updated'
+
+    expect(legacy_message.title).to eq('Updated')
+  end
+
+  it 'rejects unknown members' do
+    expect { described_class.new(unknown: 'value') }.to raise_error ArgumentError
+  end
+
+  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(:push).with(0).arguments }
+
+  describe '#push' do
+    before { allow(Warning).to receive(:warn) }
+
+    context 'with supported legacy fields' do
+      let(:request) { {} }
+      let(:response) { legacy_message.push }
+      let(:params) do
+        {
+          token:     'app-token',
+          user:      'user-key',
+          message:   'Hello',
+          device:    'phone-1',
+          title:     'Greeting',
+          url:       'https://example.test/details',
+          url_title: 'Details',
+          priority:  2,
+          sound:     'siren',
+          timestamp: 1_723_990_000,
+          expire:    60,
+          retry:     30,
+          callback:  'https://example.test/callback'
+        }
+      end
+
+      before do
+        captured_request = request
+        Excon.stub(method: :post, path: '/1/messages.json') do |request_params|
+          captured_request.replace(request_params)
+          {
+            body:    Oj.dump('status' => 1, 'request' => 'request-id'),
+            headers: { 'X-Limit-App-Remaining' => '9' },
+            status:  200
+          }
+        end
+      end
+
+      it 'delegates to the shared message endpoint' do
+        response
+
+        expect(request.slice(:method, :path)).to eq(method: :post, path: '/1/messages.json')
+      end
+
+      it 'serializes supported fields through the shared resource' do
+        response
+        expected = params.except(:token).transform_keys(&:to_s).merge('token' => 'app-token')
+
+        expect(Oj.strict_load(request[:body])).to eq(expected)
+      end
+
+      it 'uses the shared JSON content type' do
+        response
+
+        expect(request[:headers]).to include('Content-Type' => 'application/json')
+      end
+
+      it 'returns the shared response' do
+        expect(response).to have_attributes(
+          status: 1, request: 'request-id', headers: include('X-Limit-App-Remaining' => '9')
+        )
+      end
+
+      it 'emits the exact migration warning once' do
+        response
+
+        expect(Warning).to have_received(:warn).with(
+          a_string_including('Pushover::Message#push is deprecated; use Pushover::Client.new(token: ...).messages.create(...)'),
+          category: nil
+        ).once
+      end
+    end
+
+    it 'returns Pushover errors from the shared resource' do
+      Excon.stub(method: :post, path: '/1/messages.json') do |_request_params|
+        { body: Oj.dump('status' => 0, 'errors' => ['user identifier is invalid']), status: 400 }
+      end
+
+      expect(legacy_message.push).to have_attributes(status: 0, errors: ['user identifier is invalid'])
+    end
+
+    %i[token user message].each do |parameter|
+      it "preserves the legacy missing-#{parameter} error" do
+        instance = described_class.new(params.except(parameter))
+
+        expect { instance.push }.to raise_error RuntimeError, "#{parameter} must be supplied"
+      end
     end
 
-    ['token', 'user', 'message'].each do |param|
-      context "when #{param} is not supplied" do
-        before { params.delete param }
+    ['', 'raw attachment'].each do |attachment|
+      it 'rejects a non-nil raw attachment explicitly' do
+        instance = described_class.new(params.merge(attachment: attachment))
 
-        it { expect { described_class.new(params).push }.to raise_error RuntimeError, /#{param} must be supplied/ }
+        expect { instance.push }.to raise_error ArgumentError, /raw attachment is unsupported/
       end
     end
   end