pushover 3.0.2 → 4.0.0

data/spec/pushover/sounds_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe Pushover::Sounds do
+  subject(:sounds) { Pushover::Client.new(token: 'app-token').sounds }
+
+  let(:available_sounds) do
+    {
+      'pushover'     => 'Pushover (default)',
+      'bike'         => 'Bike',
+      'custom-alert' => 'Custom Alert'
+    }
+  end
+
+  after { Excon.stubs.clear }
+
+  describe '#get' do
+    context 'when Pushover returns available sounds' do
+      let(:request) { {} }
+      let(:response) { sounds.get }
+
+      before do
+        captured_request = request
+        Excon.stub(
+          method: :get,
+          path:   '/1/sounds.json',
+          query:  { token: 'app-token' },
+          body:   nil
+        ) do |params|
+          captured_request.replace(params)
+          {
+            body:    Oj.dump('status' => 1, 'request' => 'request-id', 'sounds' => available_sounds),
+            headers: { 'X-Limit-App-Remaining' => '9' },
+            status:  200
+          }
+        end
+      end
+
+      it 'gets sounds with the application token in the query string' do
+        response
+
+        expect(request.slice(:method, :path, :query)).to eq(
+          method: :get, path: '/1/sounds.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 built-in and custom sounds' do
+        expect(response.attributes).to eq('sounds' => available_sounds)
+      end
+
+      it 'preserves response headers' do
+        expect(response.headers).to include('X-Limit-App-Remaining' => '9')
+      end
+    end
+
+    context 'when Pushover rejects the application token' do
+      before do
+        Excon.stub(
+          { method: :get, path: '/1/sounds.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 = sounds.get
+
+        expect(response).to have_attributes(status: 0, errors: ['application token is invalid'])
+      end
+
+      it 'preserves endpoint-specific error details' do
+        expect(sounds.get.attributes).to eq('token' => 'invalid')
+      end
+    end
+  end
+end

data/spec/pushover/subscriptions_spec.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+
+describe Pushover::Subscriptions do
+  subject(:subscriptions) { Pushover::Client.new(token: 'app-token').subscriptions }
+
+  let(:subscription) { 'Forum-f504h08fhlasdfj' }
+  let(:user) { 'u' * 30 }
+
+  after { Excon.stubs.clear }
+
+  it 'does not expose import as a public alias' do
+    expect(subscriptions).not_to respond_to(:import)
+  end
+
+  describe '#migrate' do
+    context 'with all documented fields' do
+      let(:request) { {} }
+      let(:response) do
+        subscriptions.migrate(
+          subscription: subscription,
+          user:         user,
+          device_name:  'phone-1',
+          sound:        'custom-sound'
+        )
+      end
+      let(:expected_body) do
+        {
+          'token'        => 'app-token',
+          'subscription' => subscription,
+          'user'         => user,
+          'device_name'  => 'phone-1',
+          'sound'        => 'custom-sound'
+        }
+      end
+
+      before do
+        captured_request = request
+        Excon.stub(method: :post, path: '/1/subscriptions/migrate.json') do |params|
+          captured_request.replace(params)
+          {
+            body:    Oj.dump(
+              'status'              => 1,
+              'request'             => 'request-id',
+              'subscribed_user_key' => 's' * 30
+            ),
+            headers: { 'X-Request-Id' => 'header-id' },
+            status:  200
+          }
+        end
+      end
+
+      it 'posts to the subscription migration endpoint' do
+        response
+
+        expect(request.slice(:method, :path)).to eq(
+          method: :post, path: '/1/subscriptions/migrate.json'
+        )
+      end
+
+      it 'serializes the application token and migration fields with string keys' do
+        response
+
+        expect(Oj.strict_load(request[:body])).to eq(expected_body)
+      end
+
+      it 'uses the JSON content type' do
+        response
+
+        expect(request[:headers]).to include('Content-Type' => 'application/json')
+      end
+
+      it 'returns response metadata and the subscribed user key' do
+        expect(response).to have_attributes(
+          status:     1,
+          request:    'request-id',
+          attributes: { 'subscribed_user_key' => 's' * 30 }
+        )
+      end
+
+      it 'preserves response headers' do
+        expect(response.headers).to include('X-Request-Id' => 'header-id')
+      end
+    end
+
+    context 'without optional fields' do
+      let(:request) { {} }
+
+      before do
+        captured_request = request
+        Excon.stub(method: :post, path: '/1/subscriptions/migrate.json') do |params|
+          captured_request.replace(params)
+          { body: Oj.dump('status' => 1, 'request' => 'request-id'), status: 200 }
+        end
+
+        subscriptions.migrate(subscription: subscription, user: user)
+      end
+
+      it 'omits device_name and sound from the JSON body' do
+        expect(Oj.strict_load(request[:body])).to eq(
+          'token' => 'app-token', 'subscription' => subscription, 'user' => user
+        )
+      end
+    end
+
+    context 'with a blank sound' do
+      let(:request) { {} }
+
+      before do
+        captured_request = request
+        Excon.stub(method: :post, path: '/1/subscriptions/migrate.json') do |params|
+          captured_request.replace(params)
+          { body: Oj.dump('status' => 1, 'request' => 'request-id'), status: 200 }
+        end
+
+        subscriptions.migrate(subscription: subscription, user: user, sound: '')
+      end
+
+      it 'preserves the documented default-sound selection' do
+        expect(Oj.strict_load(request[:body])).to include('sound' => '')
+      end
+    end
+
+    context 'when Pushover rejects the migration' do
+      before do
+        Excon.stub(
+          { method: :post, path: '/1/subscriptions/migrate.json' },
+          {
+            body:   Oj.dump(
+              'status'  => 0,
+              'request' => 'request-id',
+              'errors'  => ['subscription is invalid'],
+              'user'    => 'invalid'
+            ),
+            status: 400
+          }
+        )
+      end
+
+      it 'returns API errors and preserves endpoint-specific details' do
+        expect(subscriptions.migrate(subscription: subscription, user: user)).to have_attributes(
+          status: 0, request: 'request-id', errors: ['subscription is invalid'], attributes: { 'user' => 'invalid' }
+        )
+      end
+    end
+
+    [nil, ''].each do |invalid_subscription|
+      it 'requires a subscription code' do
+        expect { subscriptions.migrate(subscription: invalid_subscription, user: user) }
+          .to raise_error ArgumentError, /subscription must be supplied/
+      end
+    end
+
+    it 'requires the subscription code to be a string' do
+      expect { subscriptions.migrate(subscription: 123, user: user) }
+        .to raise_error ArgumentError, /subscription must be a String/
+    end
+
+    [nil, ''].each do |invalid_user|
+      it 'requires a user key' do
+        expect { subscriptions.migrate(subscription: subscription, user: invalid_user) }
+          .to raise_error ArgumentError, /user must be supplied/
+      end
+    end
+
+    ['u' * 29, 'u' * 31, "#{'u' * 29}-", 123].each do |invalid_user|
+      it 'requires a 30-character alphanumeric user key' do
+        expect { subscriptions.migrate(subscription: subscription, user: invalid_user) }
+          .to raise_error ArgumentError, /user must be 30 alphanumeric characters/
+      end
+    end
+
+    ['', 'd' * 26, 'invalid device', 'phone,watch', 123].each do |invalid_device|
+      it 'validates an optional device name' do
+        expect do
+          subscriptions.migrate(subscription: subscription, user: user, device_name: invalid_device)
+        end.to raise_error ArgumentError, /device_name must be 1 to 25/
+      end
+    end
+
+    it 'requires an optional sound to be a string' do
+      expect { subscriptions.migrate(subscription: subscription, user: user, sound: 123) }
+        .to raise_error ArgumentError, /sound must be a String/
+    end
+  end
+end

data/spec/pushover/teams_spec.rb

@@ -0,0 +1,325 @@
+require 'spec_helper'
+
+describe Pushover::Teams do
+  subject(:teams) { Pushover::Client.new(token: 'team-token').teams }
+
+  after { Excon.stubs.clear }
+
+  describe '#get' do
+    context 'when Pushover returns team information' do
+      let(:request) { {} }
+      let(:response) { teams.get }
+      let(:team_attributes) do
+        {
+          'name'  => 'Operations',
+          'users' => [
+            {
+              'id'            => 'member-id',
+              'name'          => 'Team Member',
+              'email'         => 'member@example.test',
+              'administrator' => true,
+              'devices'       => [
+                {
+                  'name'                      => 'iphone',
+                  'os'                        => 'iOS',
+                  'os_version'                => '26',
+                  'enabled'                   => true,
+                  'administratively_disabled' => false
+                }
+              ]
+            }
+          ]
+        }
+      end
+
+      before do
+        captured_request = request
+        Excon.stub(
+          method: :get,
+          path:   '/1/teams.json',
+          query:  { token: 'team-token' },
+          body:   nil
+        ) do |params|
+          captured_request.replace(params)
+          {
+            body:    Oj.dump({ 'status' => 1, 'request' => 'request-id' }.merge(team_attributes)),
+            headers: { 'X-Request-Id' => 'header-id' },
+            status:  200
+          }
+        end
+      end
+
+      it 'gets the team with the team token in the query string' do
+        response
+
+        expect(request.slice(:method, :path, :query)).to eq(
+          method: :get, path: '/1/teams.json', query: 'token=team-token'
+        )
+      end
+
+      it 'does not send a request body' do
+        response
+
+        expect(request).not_to have_key(:body)
+      end
+
+      it 'preserves the team, users, and nested devices' do
+        expect(response).to have_attributes(
+          status: 1, request: 'request-id', headers: include('X-Request-Id' => 'header-id'), attributes: team_attributes
+        )
+      end
+    end
+
+    context 'when Pushover rejects the team token' do
+      before do
+        Excon.stub(
+          { method: :get, path: '/1/teams.json', query: { token: 'team-token' }, body: nil },
+          {
+            body:   Oj.dump('status' => 0, 'request' => 'request-id', 'errors' => ['team token is invalid']),
+            status: 400
+          }
+        )
+      end
+
+      it 'returns errors from the 400 response' do
+        expect(teams.get).to have_attributes(
+          status: 0, request: 'request-id', errors: ['team token is invalid']
+        )
+      end
+    end
+  end
+
+  describe '#add_user' do
+    context 'with all documented fields' do
+      let(:request) { {} }
+      let(:expected_body) do
+        {
+          'token'    => 'team-token',
+          'email'    => 'member@example.test',
+          'name'     => 'Team Member',
+          'password' => 'temporary password',
+          'instant'  => 'true',
+          'admin'    => 'true',
+          'group'    => 'On-call'
+        }
+      end
+      let(:response) do
+        teams.add_user(
+          email:    'member@example.test',
+          name:     'Team Member',
+          password: 'temporary password',
+          instant:  true,
+          admin:    true,
+          group:    'On-call'
+        )
+      end
+
+      before do
+        captured_request = request
+        Excon.stub(method: :post, path: '/1/teams/add_user.json') do |params|
+          captured_request.replace(params)
+          {
+            body:    Oj.dump('status' => 1, 'request' => 'request-id'),
+            headers: { 'X-Request-Id' => 'header-id' },
+            status:  200
+          }
+        end
+      end
+
+      it 'posts to the add-user endpoint' do
+        response
+
+        expect(request.slice(:method, :path)).to eq(
+          method: :post, path: '/1/teams/add_user.json'
+        )
+      end
+
+      it 'serializes string-key JSON and literal true flag values' do
+        response
+
+        expect(Oj.strict_load(request[:body])).to eq(expected_body)
+      end
+
+      it 'uses the JSON content type' do
+        response
+
+        expect(request[:headers]).to include('Content-Type' => 'application/json')
+      end
+
+      it 'returns response metadata and headers' do
+        expect(response).to have_attributes(
+          status: 1, request: 'request-id', attributes: {}, headers: include('X-Request-Id' => 'header-id')
+        )
+      end
+    end
+
+    context 'with only an e-mail address' do
+      let(:request) { {} }
+
+      before do
+        captured_request = request
+        Excon.stub(method: :post, path: '/1/teams/add_user.json') do |params|
+          captured_request.replace(params)
+          { body: Oj.dump('status' => 1, 'request' => 'request-id'), status: 200 }
+        end
+
+        teams.add_user(email: 'member@example.test')
+      end
+
+      it 'omits optional fields' do
+        expect(Oj.strict_load(request[:body])).to eq(
+          'token' => 'team-token', 'email' => 'member@example.test'
+        )
+      end
+    end
+
+    context 'with blank text fields and disabled flags' do
+      let(:request) { {} }
+      let(:expected_body) do
+        {
+          'token'    => 'team-token',
+          'email'    => 'member@example.test',
+          'name'     => '',
+          'password' => '',
+          'group'    => ''
+        }
+      end
+
+      before do
+        captured_request = request
+        Excon.stub(method: :post, path: '/1/teams/add_user.json') do |params|
+          captured_request.replace(params)
+          { body: Oj.dump('status' => 1, 'request' => 'request-id'), status: 200 }
+        end
+
+        teams.add_user(
+          email: 'member@example.test', name: '', password: '', instant: false, admin: false, group: ''
+        )
+      end
+
+      it 'preserves blank strings and omits false flags' do
+        expect(Oj.strict_load(request[:body])).to eq(expected_body)
+      end
+    end
+
+    context 'when Pushover rejects the request' do
+      before do
+        Excon.stub(
+          { method: :post, path: '/1/teams/add_user.json' },
+          {
+            body:   Oj.dump('status' => 0, 'request' => 'request-id', 'errors' => ['user could not be added']),
+            status: 400
+          }
+        )
+      end
+
+      it 'returns errors from the 400 response' do
+        expect(teams.add_user(email: 'member@example.test')).to have_attributes(
+          status: 0, request: 'request-id', errors: ['user could not be added']
+        )
+      end
+    end
+
+    [nil, '', '   ', 123].each do |invalid_email|
+      it 'requires a nonblank e-mail string' do
+        expect { teams.add_user(email: invalid_email) }
+          .to raise_error ArgumentError, /email must be a nonblank String/
+      end
+    end
+
+    %i[name password group].each do |field|
+      it "requires #{field} to be a string when supplied" do
+        expect { teams.add_user(email: 'member@example.test', field => 123) }
+          .to raise_error ArgumentError, /#{field} must be a String/
+      end
+    end
+
+    %i[instant admin].each do |field|
+      it "requires #{field} to be boolean when supplied" do
+        expect { teams.add_user(email: 'member@example.test', field => 'true') }
+          .to raise_error ArgumentError, /#{field} must be true or false/
+      end
+    end
+
+    it 'rejects unsupported fields' do
+      expect { teams.add_user(email: 'member@example.test', role: 'owner') }
+        .to raise_error ArgumentError, /unsupported team user parameter: role/
+    end
+  end
+
+  shared_examples 'a team e-mail mutation' do |operation, path|
+    let(:request) { {} }
+    let(:response) { teams.public_send(operation, email: 'member@example.test') }
+    let(:api_response) do
+      {
+        body:    Oj.dump('status' => 1, 'request' => 'request-id'),
+        headers: { 'X-Request-Id' => 'header-id' },
+        status:  200
+      }
+    end
+
+    before do
+      captured_request = request
+      Excon.stub(method: :post, path: path) do |params|
+        captured_request.replace(params)
+        api_response
+      end
+    end
+
+    it 'posts to the documented endpoint' do
+      response
+
+      expect(request.slice(:method, :path)).to eq(method: :post, path: path)
+    end
+
+    it 'serializes the team token and e-mail with string keys' do
+      response
+
+      expect(Oj.strict_load(request[:body])).to eq(
+        'token' => 'team-token', 'email' => 'member@example.test'
+      )
+    end
+
+    it 'uses the JSON content type' do
+      response
+
+      expect(request[:headers]).to include('Content-Type' => 'application/json')
+    end
+
+    it 'returns response metadata and headers' do
+      expect(response).to have_attributes(
+        status: 1, request: 'request-id', attributes: {}, headers: include('X-Request-Id' => 'header-id')
+      )
+    end
+
+    context 'when Pushover rejects the request' do
+      let(:api_response) do
+        {
+          body:   Oj.dump('status' => 0, 'request' => 'request-id', 'errors' => ['team operation failed']),
+          status: 400
+        }
+      end
+
+      it 'returns errors from the 400 response' do
+        expect(response).to have_attributes(
+          status: 0, request: 'request-id', errors: ['team operation failed']
+        )
+      end
+    end
+
+    [nil, '', '   ', 123].each do |invalid_email|
+      it 'requires a nonblank e-mail string' do
+        expect { teams.public_send(operation, email: invalid_email) }
+          .to raise_error ArgumentError, /email must be a nonblank String/
+      end
+    end
+  end
+
+  describe '#revoke_invitation' do
+    it_behaves_like 'a team e-mail mutation', :revoke_invitation, '/1/teams/revoke_invitation.json'
+  end
+
+  describe '#remove_user' do
+    it_behaves_like 'a team e-mail mutation', :remove_user, '/1/teams/remove_user.json'
+  end
+end