pushover 3.0.3 → 4.0.0

data/spec/pushover/glances_spec.rb

@@ -0,0 +1,206 @@
+require 'spec_helper'
+
+describe Pushover::Glances do
+  subject(:glances) { Pushover::Client.new(token: 'app-token').glances }
+
+  let(:user) { 'u' * 30 }
+
+  after { Excon.stubs.clear }
+
+  describe '#update' do
+    context 'with a complete update' do
+      let(:request) { {} }
+      let(:response) do
+        glances.update(
+          user: user, device: 'watch-1', title: 'Sales', text: '30', subtext: 'Today', count: -3, percent: 42
+        )
+      end
+      let(:expected_body) do
+        {
+          'token'   => 'app-token',
+          'user'    => user,
+          'device'  => 'watch-1',
+          'title'   => 'Sales',
+          'text'    => '30',
+          'subtext' => 'Today',
+          'count'   => -3,
+          'percent' => 42
+        }
+      end
+
+      before do
+        captured_request = request
+        Excon.stub(method: :post, path: '/1/glances.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 all fields as JSON' 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' do
+        expect(response).to have_attributes(status: 1, request: 'request-id', attributes: {})
+      end
+
+      it 'preserves response headers' do
+        expect(response.headers).to include('X-Request-Id' => 'header-id')
+      end
+    end
+
+    it 'only sends fields being updated and preserves a blank value used to clear data' do
+      request = capture_successful_request
+      glances.update(user: user, title: '')
+
+      expect(Oj.strict_load(request[:body])).to eq('token' => 'app-token', 'user' => user, 'title' => '')
+    end
+
+    it 'allows numeric fields to be cleared with blank values' do
+      request = capture_successful_request
+      glances.update(user: user, count: '', percent: '')
+
+      expect(Oj.strict_load(request[:body])).to include('count' => '', 'percent' => '')
+    end
+
+    it 'accepts a blank device to target all registered widgets' do
+      request = capture_successful_request
+      glances.update(user: user, device: '', text: 'Garage open')
+
+      expect(Oj.strict_load(request[:body])).to include('device' => '')
+    end
+
+    context 'when Pushover rejects the update' do
+      let(:response) { glances.update(user: user, text: 'Garage open') }
+
+      before do
+        Excon.stub(
+          { method: :post, path: '/1/glances.json' },
+          {
+            body:   Oj.dump(
+              'status' => 0, 'request' => 'request-id', 'errors' => ['application token is invalid']
+            ),
+            status: 400
+          }
+        )
+      end
+
+      it 'returns errors from the 400 response' do
+        expect(response).to have_attributes(
+          status: 0, request: 'request-id', errors: ['application token is invalid']
+        )
+      end
+    end
+
+    [nil, ''].each do |invalid_user|
+      it 'requires a user identifier' do
+        expect { glances.update(user: invalid_user, text: 'Garage open') }
+          .to raise_error ArgumentError, /user must be supplied/
+      end
+    end
+
+    [123, 'u' * 29, 'u' * 31, "#{'u' * 29}-"].each do |invalid_user|
+      it 'requires a 30-character alphanumeric user identifier' do
+        expect { glances.update(user: invalid_user, text: 'Garage open') }
+          .to raise_error ArgumentError, /user must be 30 alphanumeric characters/
+      end
+    end
+
+    it 'requires at least one data field' do
+      expect { glances.update(user: user, device: 'watch-1') }
+        .to raise_error ArgumentError, /at least one glance data field must be supplied/
+    end
+
+    it 'treats nil data fields as omitted' do
+      expect { glances.update(user: user, text: nil) }
+        .to raise_error ArgumentError, /at least one glance data field must be supplied/
+    end
+
+    it 'rejects unsupported parameters' do
+      expect { glances.update(user: user, text: 'Garage open', priority: 1) }
+        .to raise_error ArgumentError, /unsupported glance parameter: priority/
+    end
+
+    %i[title text subtext].each do |field|
+      it "requires #{field} to be a string" do
+        expect { glances.update(user: user, field => 123) }
+          .to raise_error ArgumentError, /#{field} must be a String/
+      end
+
+      it "limits #{field} to 100 characters" do
+        expect { glances.update(user: user, field => 'a' * 101) }
+          .to raise_error ArgumentError, /#{field} must be at most 100 characters/
+      end
+    end
+
+    it 'counts multibyte text limits by characters' do
+      stub_success
+
+      expect { glances.update(user: user, text: 'é' * 100) }.not_to raise_error
+    end
+
+    it 'accepts a negative integer count' do
+      stub_success
+
+      expect { glances.update(user: user, count: -1) }.not_to raise_error
+    end
+
+    ['1', 1.5, true].each do |invalid_count|
+      it 'requires count to be an integer or blank' do
+        expect { glances.update(user: user, count: invalid_count) }
+          .to raise_error ArgumentError, /count must be an Integer or blank/
+      end
+    end
+
+    [0, 100].each do |valid_percent|
+      it "accepts percent #{valid_percent}" do
+        stub_success
+
+        expect { glances.update(user: user, percent: valid_percent) }.not_to raise_error
+      end
+    end
+
+    [-1, 101, '50', 50.5].each do |invalid_percent|
+      it 'requires percent to be an integer from 0 to 100 or blank' do
+        expect { glances.update(user: user, percent: invalid_percent) }
+          .to raise_error ArgumentError, /percent must be an Integer from 0 to 100 or blank/
+      end
+    end
+
+    [123, 'a' * 26, 'invalid device', 'watch,phone'].each do |invalid_device|
+      it 'validates a nonblank device name' do
+        expect { glances.update(user: user, device: invalid_device, text: 'Garage open') }
+          .to raise_error ArgumentError, /device must be blank or 1 to 25 letters, numbers, underscores, or hyphens/
+      end
+    end
+
+    def stub_success
+      Excon.stub(
+        { method: :post, path: '/1/glances.json' },
+        { body: Oj.dump('status' => 1, 'request' => 'request-id'), status: 200 }
+      )
+    end
+
+    def capture_successful_request
+      request = {}
+      captured_request = request
+      Excon.stub(method: :post, path: '/1/glances.json') do |params|
+        captured_request.replace(params)
+        { body: Oj.dump('status' => 1, 'request' => 'request-id'), status: 200 }
+      end
+      request
+    end
+  end
+end

data/spec/pushover/groups_spec.rb

@@ -0,0 +1,486 @@
+require 'spec_helper'
+
+describe Pushover::Groups do
+  subject(:groups) { Pushover::Client.new(token: 'app-token').groups }
+
+  let(:group) { 'g' * 30 }
+
+  after { Excon.stubs.clear }
+
+  describe '#create' do
+    context 'with a group name' do
+      let(:request) { {} }
+      let(:response) { groups.create(name: 'On-call West') }
+
+      before do
+        captured_request = request
+        Excon.stub(method: :post, path: '/1/groups.json') do |params|
+          captured_request.replace(params)
+          {
+            body:    Oj.dump('status' => 1, 'request' => 'request-id', 'group' => group),
+            headers: { 'X-Request-Id' => 'header-id' },
+            status:  200
+          }
+        end
+      end
+
+      it 'posts to the group creation endpoint' do
+        response
+
+        expect(request.slice(:method, :path)).to eq(method: :post, path: '/1/groups.json')
+      end
+
+      it 'posts the application token and name as JSON' do
+        response
+
+        expect(Oj.strict_load(request[:body])).to eq('token' => 'app-token', 'name' => 'On-call West')
+      end
+
+      it 'uses the JSON content type' do
+        response
+
+        expect(request[:headers]).to include('Content-Type' => 'application/json')
+      end
+
+      it 'returns response metadata' do
+        expect(response).to have_attributes(status: 1, request: 'request-id')
+      end
+
+      it 'returns the new group key' do
+        expect(response.attributes).to eq('group' => group)
+      end
+
+      it 'preserves response headers' do
+        expect(response.headers).to include('X-Request-Id' => 'header-id')
+      end
+    end
+
+    context 'when Pushover rejects the request' do
+      let(:response) { groups.create(name: 'On-call West') }
+
+      before do
+        Excon.stub(
+          { method: :post, path: '/1/groups.json' },
+          {
+            body:   Oj.dump(
+              'status' => 0, 'request' => 'request-id', 'errors' => ['application token is invalid']
+            ),
+            status: 400
+          }
+        )
+      end
+
+      it 'returns errors from the 400 response' do
+        expect(response).to have_attributes(
+          status: 0, request: 'request-id', errors: ['application token is invalid']
+        )
+      end
+    end
+
+    [nil, ''].each do |invalid_name|
+      it 'requires a group name' do
+        expect { groups.create(name: invalid_name) }.to raise_error ArgumentError, /name must be supplied/
+      end
+    end
+
+    it 'requires the group name to be a string' do
+      expect { groups.create(name: 123) }.to raise_error ArgumentError, /name must be a String/
+    end
+  end
+
+  describe '#list' do
+    context 'when the account owns groups' do
+      let(:request) { {} }
+      let(:listed_groups) do
+        [
+          { 'group' => group, 'name' => 'On-call West' },
+          { 'group' => 'h' * 30, 'name' => 'Operations' }
+        ]
+      end
+      let(:response) { groups.list }
+
+      before do
+        captured_request = request
+        Excon.stub(
+          method: :get,
+          path:   '/1/groups.json',
+          query:  { token: 'app-token' },
+          body:   nil
+        ) do |params|
+          captured_request.replace(params)
+          {
+            body:    Oj.dump('status' => 1, 'request' => 'request-id', 'groups' => listed_groups),
+            headers: { 'X-Request-Id' => 'header-id' },
+            status:  200
+          }
+        end
+      end
+
+      it 'gets groups with the application token in the query string' do
+        response
+
+        expect(request.slice(:method, :path, :query)).to eq(
+          method: :get, path: '/1/groups.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 each group key and name without reordering' do
+        expect(response.attributes).to eq('groups' => listed_groups)
+      end
+
+      it 'preserves response headers' do
+        expect(response.headers).to include('X-Request-Id' => 'header-id')
+      end
+    end
+
+    context 'when the account has no groups' do
+      before do
+        Excon.stub(
+          { method: :get, path: '/1/groups.json', query: { token: 'app-token' }, body: nil },
+          { body: Oj.dump('status' => 1, 'request' => 'request-id', 'groups' => []), status: 200 }
+        )
+      end
+
+      it 'returns an empty groups array' do
+        expect(groups.list.attributes).to eq('groups' => [])
+      end
+    end
+
+    context 'when Pushover rejects the request' do
+      let(:response) { groups.list }
+
+      before do
+        Excon.stub(
+          { method: :get, path: '/1/groups.json', query: { token: 'app-token' }, body: nil },
+          {
+            body:   Oj.dump(
+              'status' => 0, 'request' => 'request-id', 'errors' => ['application token is invalid']
+            ),
+            status: 400
+          }
+        )
+      end
+
+      it 'returns errors from the 400 response' do
+        expect(response).to have_attributes(
+          status: 0, request: 'request-id', errors: ['application token is invalid']
+        )
+      end
+    end
+  end
+
+  describe '#get' do
+    context 'with a valid group' do
+      let(:request) { {} }
+      let(:group_users) do
+        [
+          { 'user' => 'u' * 30, 'device' => nil, 'memo' => 'Jim', 'disabled' => false },
+          {
+            'user'     => 'v' * 30,
+            'device'   => 'iphone',
+            'memo'     => 'Mary',
+            'disabled' => true,
+            'name'     => 'Mary Example',
+            'email'    => 'mary@example.test'
+          }
+        ]
+      end
+      let(:group_attributes) { { 'name' => 'On-call West', 'users' => group_users } }
+      let(:response) { groups.get(group: group) }
+
+      before do
+        captured_request = request
+        Excon.stub(
+          method: :get,
+          path:   "/1/groups/#{group}.json",
+          query:  { token: 'app-token' },
+          body:   nil
+        ) do |params|
+          captured_request.replace(params)
+          {
+            body:    Oj.dump({ 'status' => 1, 'request' => 'request-id' }.merge(group_attributes)),
+            headers: { 'X-Request-Id' => 'header-id' },
+            status:  200
+          }
+        end
+      end
+
+      it 'gets the group with the application token in the query string' do
+        response
+
+        expect(request.slice(:method, :path, :query)).to eq(
+          method: :get, path: "/1/groups/#{group}.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 group name and membership fields without reordering' do
+        expect(response.attributes).to eq(group_attributes)
+      end
+
+      it 'preserves response headers' do
+        expect(response.headers).to include('X-Request-Id' => 'header-id')
+      end
+    end
+
+    context 'when the group has no users' do
+      before do
+        Excon.stub(
+          { method: :get, path: "/1/groups/#{group}.json", query: { token: 'app-token' }, body: nil },
+          {
+            body:   Oj.dump('status' => 1, 'request' => 'request-id', 'name' => 'Empty Group', 'users' => []),
+            status: 200
+          }
+        )
+      end
+
+      it 'returns an empty users array' do
+        expect(groups.get(group: group).attributes).to eq('name' => 'Empty Group', 'users' => [])
+      end
+    end
+
+    context 'when Pushover rejects the request' do
+      let(:response) { groups.get(group: group) }
+
+      before do
+        Excon.stub(
+          { method: :get, path: "/1/groups/#{group}.json", query: { token: 'app-token' }, body: nil },
+          {
+            body:   Oj.dump('status' => 0, 'request' => 'request-id', 'errors' => ['group is invalid']),
+            status: 400
+          }
+        )
+      end
+
+      it 'returns errors from the 400 response' do
+        expect(response).to have_attributes(status: 0, request: 'request-id', errors: ['group is invalid'])
+      end
+    end
+
+    [nil, ''].each do |invalid_group|
+      it 'requires a group key' do
+        expect { groups.get(group: invalid_group) }.to raise_error ArgumentError, /group must be supplied/
+      end
+    end
+
+    ['g' * 29, 'g' * 31, "#{'g' * 29}-", 123].each do |invalid_group|
+      it 'requires exactly 30 alphanumeric characters' do
+        expect { groups.get(group: invalid_group) }
+          .to raise_error ArgumentError, /group must be 30 alphanumeric characters/
+      end
+    end
+  end
+
+  shared_examples 'a group mutation' do |operation, action, arguments, expected_body|
+    let(:request) { {} }
+    let(:response) { groups.public_send(operation, **arguments) }
+    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: "/1/groups/#{arguments[:group]}/#{action}.json") 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: "/1/groups/#{arguments[:group]}/#{action}.json"
+      )
+    end
+
+    it 'serializes the documented string-key JSON body' 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
+
+    context 'when Pushover rejects the request' do
+      let(:api_response) do
+        {
+          body:   Oj.dump('status' => 0, 'request' => 'request-id', 'errors' => ['group operation failed']),
+          status: 400
+        }
+      end
+
+      it 'returns errors from the 400 response' do
+        expect(response).to have_attributes(
+          status: 0, request: 'request-id', errors: ['group operation failed']
+        )
+      end
+    end
+  end
+
+  describe '#add_user' do
+    it_behaves_like(
+      'a group mutation',
+      :add_user,
+      'add_user',
+      { group: 'g' * 30, user: 'u' * 30, device: 'd' * 25, memo: 'é' * 200 },
+      {
+        'token'  => 'app-token',
+        'user'   => 'u' * 30,
+        'device' => 'd' * 25,
+        'memo'   => 'é' * 200
+      }
+    )
+
+    [
+      [{ device: nil, memo: nil }, { 'token' => 'app-token', 'user' => 'u' * 30 }],
+      [
+        { device: '', memo: '' },
+        { 'token' => 'app-token', 'user' => 'u' * 30, 'device' => '', 'memo' => '' }
+      ]
+    ].each do |optional_fields, expected_body|
+      context "with #{optional_fields.values.compact.empty? ? 'nil' : 'blank'} optional fields" do
+        let(:request) { {} }
+
+        before do
+          captured_request = request
+          Excon.stub(method: :post, path: "/1/groups/#{group}/add_user.json") do |params|
+            captured_request.replace(params)
+            { body: Oj.dump('status' => 1, 'request' => 'request-id'), status: 200 }
+          end
+          groups.add_user(group: group, user: 'u' * 30, **optional_fields)
+        end
+
+        it 'distinguishes omitted fields from explicit blanks' do
+          expect(Oj.strict_load(request[:body])).to eq(expected_body)
+        end
+      end
+    end
+
+    [nil, ''].each do |invalid_user|
+      it 'requires a user key' do
+        expect { groups.add_user(group: group, 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 { groups.add_user(group: group, 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 'requires a blank or valid single device name' do
+        expect { groups.add_user(group: group, user: 'u' * 30, device: invalid_device) }
+          .to raise_error ArgumentError, /device must be blank or 1 to 25/
+      end
+    end
+
+    it 'limits memos to 200 characters' do
+      expect { groups.add_user(group: group, user: 'u' * 30, memo: 'é' * 201) }
+        .to raise_error ArgumentError, /memo must be at most 200 characters/
+    end
+
+    it 'requires memos to be strings' do
+      expect { groups.add_user(group: group, user: 'u' * 30, memo: 123) }
+        .to raise_error ArgumentError, /memo must be a String/
+    end
+
+    it 'validates the group key before posting' do
+      expect { groups.add_user(group: 'invalid', user: 'u' * 30) }
+        .to raise_error ArgumentError, /group must be 30 alphanumeric characters/
+    end
+  end
+
+  describe '#remove_user' do
+    it_behaves_like(
+      'a group mutation',
+      :remove_user,
+      'remove_user',
+      { group: 'g' * 30, user: 'u' * 30 },
+      { 'token' => 'app-token', 'user' => 'u' * 30 }
+    )
+  end
+
+  describe '#disable_user' do
+    it_behaves_like(
+      'a group mutation',
+      :disable_user,
+      'disable_user',
+      { group: 'g' * 30, user: 'u' * 30, device: 'phone_1' },
+      { 'token' => 'app-token', 'user' => 'u' * 30, 'device' => 'phone_1' }
+    )
+  end
+
+  describe '#enable_user' do
+    it_behaves_like(
+      'a group mutation',
+      :enable_user,
+      'enable_user',
+      { group: 'g' * 30, user: 'u' * 30, device: '' },
+      { 'token' => 'app-token', 'user' => 'u' * 30, 'device' => '' }
+    )
+  end
+
+  describe '#rename' do
+    it_behaves_like(
+      'a group mutation',
+      :rename,
+      'rename',
+      { group: 'g' * 30, name: 'Operations' },
+      { 'token' => 'app-token', 'name' => 'Operations' }
+    )
+
+    [nil, ''].each do |invalid_name|
+      it 'requires a group name' do
+        expect { groups.rename(group: group, name: invalid_name) }
+          .to raise_error ArgumentError, /name must be supplied/
+      end
+    end
+
+    it 'requires the group name to be a string' do
+      expect { groups.rename(group: group, name: 123) }
+        .to raise_error ArgumentError, /name must be a String/
+    end
+
+    it 'validates the group key before posting' do
+      expect { groups.rename(group: 'invalid', name: 'Operations') }
+        .to raise_error ArgumentError, /group must be 30 alphanumeric characters/
+    end
+  end
+end