opium 1.5.2 → 1.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: df649015596245c055a437ab8d6946fa2c6badd7
-  data.tar.gz: 35c58b1cc03b4bc34c4ea74fae80eafa691fa1e6
+  metadata.gz: eb9239c124be4e458967d7fe92d4073ea2cb996b
+  data.tar.gz: ee2dd7e877cfcd1892659b8645daa4b08cc9fc99
 SHA512:
-  metadata.gz: 1bd35e1c4a44a923d3bbc1a2b76800b8e166b98ad450a33ec0a32b3708063224dd283e28bf4ecf5b576d1f783bd57120a556732bf659a654506fe5749957732e
-  data.tar.gz: 71c2ab4dcc1457000e07abfac7e28165568212b86bdd61564950a605a80cd61c93c28ed82bcde2c68c122815e99b23023c749093e13a53cb4348235764640f62
+  metadata.gz: 770af57f72afb14bcf366157f7c3f4b7c628b44e0877e382441f628d2c2379d5e1449c07e57b7f59af6e3f4bc211e616a3d60139facf12d5f8d05d5aaff341d2
+  data.tar.gz: 9fb435ce9b0acfe2ebb5a18282cc6e5adb684fe5e83a818322cab5d1f04c213fb6fcdc9ff835690e9670016302fd2004da30607cfa7693415b18ff7b0cee3973

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 1.5.3
+### New Features
+- #54: Installation queries are now supported by Opium::Push to perform a more finely targeted push.
+- #55: Introduction of Opium::Installation, which allows for access and manipulation of Parse's Installation object.
+- Opium::Push has an expanded set of attributes which may be set to further customize a push, including the ability to schedule a push for a particular time and expire pushes.
+
 ## 1.5.2
 ### Resolved Issues
 - Push should now use the master key for creating notifications, rather than the REST API key.

data/README.md

@@ -56,12 +56,20 @@ A generator exists for creating new models; this should be invoked whenever `rai
 $ rails g model game title:string price:float
 ```
 
-A separate generate is available for creating a model to wrap Parse's User model:
+A separate generator is available for creating a model to wrap Parse's User model:
 
 ```bash
 $ rails g opium:user
 ```
 
+Finally, another generator is available to further customize Parse's Installation model:
+
+```bash
+$ rails g opium:installation
+```
+
+Both of these latter two generators otherwise accept the same arguments as the generic model generator.
+
 ### Specifying a model
 
 Models are defined by mixing in `Opium::Model` into a new class. Class names should match the names of the

data/lib/generators/opium/installation_generator.rb

@@ -0,0 +1,16 @@
+require 'rails/generators'
+require 'generators/opium/model_generator'
+
+module Opium
+  module Generators
+    class InstallationGenerator < ::Rails::Generators::Base
+      desc "Creates an Opium installation model"
+
+      argument :attributes, type: :array, default: [], banner: "field:type field:type"
+
+      def run_model_generator
+        generate 'model', *['installation', *attributes, '--parent=opium/installation']
+      end
+    end
+  end
+end

data/lib/opium/installation.rb

@@ -0,0 +1,22 @@
+module Opium
+  class Installation
+    include Opium::Model
+
+    no_object_prefix!
+    requires_heightened_privileges!
+
+    field :badge, type: Integer
+    field :channels, type: Array
+    field :time_zone, type: String
+    field :device_type, type: Symbol, readonly: true
+    field :push_type, type: Symbol, readonly: true
+    field :gcm_sender_id, type: Integer
+    field :installation_id, type: String, readonly: true
+    field :device_token, type: String
+    field :channel_uris, type: Array
+    field :app_name, type: String
+    field :app_version, type: String
+    field :parse_version, type: String
+    field :app_identifier, type: String
+  end
+end

data/lib/opium/push.rb

@@ -4,25 +4,46 @@ module Opium
   class Push
     include Opium::Model::Connectable
 
+    class << self
+      private
+
+      def attr_hash_accessors( hash_name, *methods )
+        methods.each do |method_name|
+          attr_hash_accessor( hash_name, method_name )
+        end
+      end
+
+      def attr_hash_accessor( hash_name, method_name )
+        unless respond_to?( method_name )
+          define_method method_name do
+            self.send( hash_name )[ method_name ]
+          end
+        end
+        setter = "#{ method_name }="
+        unless respond_to?( setter )
+          define_method setter do |value|
+            self.send( hash_name )[ method_name ] = value
+          end
+        end
+      end
+    end
+
     requires_heightened_privileges!
 
     def initialize( attributes = {} )
       self.channels = []
       self.data = {}.with_indifferent_access
+      attributes.each {|k, v| self.send( "#{k}=", v )}
     end
 
-    attr_accessor :channels, :data
+    attr_accessor :channels, :where, :data, :push_at, :expires_at, :expiration_interval
 
-    def alert
-      data[:alert]
-    end
+    alias_method :criteria, :where
+    alias_method :criteria=, :where=
 
-    def alert=( value )
-      self.data[:alert] = value
-    end
+    attr_hash_accessors :data, :alert, :badge, :sound, :content_available, :category, :uri, :title
 
     def create
-      fail ArgumentError, 'No channels were specified!' if channels.empty?
       self.class.as_resource(:push) do
         result = self.class.http_post post_data
         result[:result]
@@ -32,10 +53,37 @@ module Opium
     private
 
     def post_data
-      {
-        channels: self.channels,
-        data: self.data
-      }
+      {}.tap do |pd|
+        targetize!( pd )
+        schedulize!( pd )
+        pd[:data] = data
+      end
+    end
+
+    def targetize!( hash )
+      if criteria
+        c = criteria
+        c = Installation.where( c ) unless c.is_a?( Opium::Model::Criteria )
+        c = c.and( channels: channels ) unless channels.empty?
+        hash[:where] = c.constraints[:where]
+      elsif !channels.empty?
+        hash[:channels] = channels
+      else
+        fail ArgumentError, 'No channels or criteria were specified!'
+      end
+    end
+
+    def schedulize!( hash )
+      fail ArgumentError, 'No scheduled time for #push_at specified!' if expiration_interval && !push_at
+      if push_at
+        fail ArgumentError, 'Can only schedule a push up to 2 weeks in advance!' if push_at > ( Time.now + ( 2 * 604800 ) )
+        fail ArgumentError, 'Cannot schedule pushes in the past... unless you are the Doctor' if push_at < Time.now
+        hash[:push_time] = push_at.iso8601
+        hash[:expiration_interval] = expiration_interval
+      elsif expires_at
+        fail ArgumentError, 'Cannot schedule expiration in the past... unless you have a TARDIS' if expires_at < Time.now
+        hash[:expiration_time] = expires_at.iso8601
+      end
     end
   end
 end

data/lib/opium/version.rb

@@ -1,3 +1,3 @@
 module Opium
-  VERSION = "1.5.2"
+  VERSION = "1.5.3"
 end

data/lib/opium.rb

@@ -6,6 +6,7 @@ require 'opium/config'
 require 'opium/extensions'
 require 'opium/model'
 require 'opium/user'
+require 'opium/installation'
 require 'opium/file'
 require 'opium/schema'
 require 'opium/push'

data/spec/opium/installation_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Opium::Installation do
+
+  it { described_class.should respond_to( :object_prefix ) }
+
+  it { should be_an( Opium::Model ) }
+
+  it { expect( described_class ).to have_heightened_privileges }
+
+  describe '#object_prefix' do
+    it { expect( described_class.object_prefix ).to be_empty }
+  end
+
+  describe '#resource_name' do
+    it { expect( described_class.resource_name ).to eq 'installations' }
+  end
+
+  %w{ badge channels time_zone device_type push_type gcm_sender_id
+    installation_id device_token channel_uris app_name app_version
+    parse_version app_identifier }.each do |field_name|
+    it { described_class.fields.should have_key( field_name ) }
+  end
+
+  %w{ device_type push_type installation_id }.each do |field_name|
+    describe "##{ field_name }" do
+      it { expect( described_class.fields[field_name] ).to be_readonly }
+    end
+  end
+
+  context 'within a subclass' do
+    before do
+      stub_const( 'SpecialInstallation', Class.new(Opium::Installation) do
+        field :has_web_access, type: Opium::Boolean
+      end )
+    end
+
+    subject { SpecialInstallation }
+
+    it { is_expected.to be <= Opium::Installation }
+    it { is_expected.to respond_to( :field, :fields ) }
+    it { expect( subject.fields.keys ).to include( 'badge', 'device_token', 'has_web_access' ) }
+
+    it { expect( subject ).to have_heightened_privileges }
+
+    describe '#object_prefix' do
+      it { expect( subject.object_prefix ).to be_empty }
+    end
+
+    describe '#resource_name' do
+      it { expect( subject.resource_name ).to eq 'installations' }
+    end
+  end
+end

data/spec/opium/push_spec.rb

@@ -5,73 +5,128 @@ describe Opium::Push do
 
   it { expect( described_class ).to respond_to(:to_ruby, :to_parse).with(1).argument }
 
-  it { is_expected.to respond_to( :create, :channels, :data, :alert ) }
+  it { is_expected.to respond_to( :create, :channels, :where, :data, :alert, :badge, :sound, :content_available, :category, :uri, :title, :expires_at, :push_at, :expiration_interval ) }
 
-  describe '#alert' do
+  shared_examples_for 'a push option getter' do |option, value|
     let(:result) do
       subject.data = data
-      subject.alert
+      subject.send(option)
     end
 
     context 'with no data' do
       let(:data) { { } }
 
-      it 'equals data[:alert]' do
+      it "equals data[:#{ option }]" do
         expect( result ).to be_nil
       end
     end
 
-    context 'with alert data' do
-      let(:data) { { alert: 'The sky is blue.' } }
+    context "with a value" do
+      let(:data) { { option => value } }
 
-      it 'equals data[:alert]' do
-        expect( result ).to eq data[:alert]
+      it "equals data[:#{ option }]" do
+        expect( result ).to eq data[option]
       end
     end
   end
 
-  describe '#alert=' do
+  shared_examples_for 'a push option setter' do |option, value|
     let(:result) do
-      subject.alert = alert
-      subject.data[:alert]
+      subject.send( "#{ option }=".to_sym, option_value )
+      subject.data[option]
     end
 
     context 'with nothing' do
-      let(:alert) { nil }
+      let(:option_value) { nil }
 
-      it 'equals data[:alert]' do
+      it "equals data[:#{ option }]" do
         expect( result ).to be_nil
       end
     end
 
-    context 'with text' do
-      let(:alert) { 'The sky is blue.' }
+    context 'with a value' do
+      let(:option_value) { value }
 
-      it 'equals data[:alert]' do
-        expect( result ).to eq alert
+      it "equals data[:#{ option }]" do
+        expect( result ).to eq option_value
       end
     end
   end
 
+  {
+    alert: 'The sky is blue.',
+    badge: 'Increment',
+    sound: 'cheering.caf',
+    content_available: 1,
+    category: 'A category',
+    uri: 'https://example.com',
+    title: 'Current Weather'
+  }.each do |option, value|
+    describe "##{ option }" do
+      it_behaves_like 'a push option getter', option, value
+    end
+
+    describe "##{ option }=" do
+      it_behaves_like 'a push option setter', option, value
+    end
+  end
+
   describe '#create' do
     let(:result) do
-      subject.tap do |push|
-        push.channels = channels
-        push.alert = alert
-      end.create
+      push.create
     end
 
+    let(:push) do
+      subject.tap do |p|
+        p.channels = channels if channels
+        p.where = criteria if criteria
+        p.alert = alert
+        p.push_at = push_at if push_at
+        p.expires_at = expires_at if expires_at
+        p.expiration_interval = expiration_interval if expiration_interval
+      end
+    end
+
+    let(:push_post_data) { push.send(:post_data) }
+
     let(:alert) { 'Zoo animals are fighting!' }
+    let(:channels) { %w{ General } }
+    let(:criteria) { nil }
+    let(:push_at) { nil }
+    let(:expires_at) { nil }
+    let(:expiration_interval) { nil }
+
+    let(:one_day_ago) { Time.now - 86400 }
+    let(:one_day_from_now) { Time.now + 86400 }
+    let(:one_week) { 604800 }
+    let(:one_week_from_now) { Time.now + one_week }
+    let(:three_weeks_from_now) { Time.now + ( 3 * one_week ) }
 
     before do
       stub_request(:post, "https://api.parse.com/1/push").
          with(body: "{\"channels\":[\"Penguins\",\"PolarBears\"],\"data\":{\"alert\":\"Zoo animals are fighting!\"}}",
-              headers: {'Content-Type'=>'application/json', 'X-Parse-Application-Id'=>'PARSE_APP_ID', 'X-Parse-Master-Key' => 'PARSE_MASTER_KEY'}).
-         to_return(:status => 200, :body => { result: true }.to_json, :headers => {content_type: 'application/json'})
+          headers: {'Content-Type'=>'application/json', 'X-Parse-Application-Id'=>'PARSE_APP_ID', 'X-Parse-Master-Key' => 'PARSE_MASTER_KEY'}).
+         to_return(status: 200, body: { result: true }.to_json, headers: {content_type: 'application/json'})
+
+      stub_request(:post, "https://api.parse.com/1/push").
+        with(body: "{\"where\":{\"deviceType\":\"ios\"},\"data\":{\"alert\":\"Zoo animals are fighting!\"}}",
+          headers: {'Content-Type'=>'application/json', 'X-Parse-Application-Id'=>'PARSE_APP_ID', 'X-Parse-Master-Key'=>'PARSE_MASTER_KEY'}).
+        to_return(status: 200, body: { result: true }.to_json, headers: { content_type: 'application/json' })
+
+      stub_request(:post, "https://api.parse.com/1/push").
+        with(body: "{\"where\":{\"deviceType\":\"ios\",\"channels\":[\"Penguins\",\"PolarBears\"]},\"data\":{\"alert\":\"Zoo animals are fighting!\"}}",
+          headers: {'Content-Type'=>'application/json', 'X-Parse-Application-Id'=>'PARSE_APP_ID', 'X-Parse-Master-Key'=>'PARSE_MASTER_KEY'}).
+        to_return(status: 200, body: { result: true }.to_json, headers: { content_type: 'application/json' })
+
+      stub_request(:post, "https://api.parse.com/1/push").
+        with(body: "{\"where\":{\"deviceType\":\"ios\",\"badge\":{\"$lte\":5},\"channels\":[\"Penguins\",\"PolarBears\"]},\"data\":{\"alert\":\"Zoo animals are fighting!\"}}",
+          headers: {'Content-Type'=>'application/json', 'X-Parse-Application-Id'=>'PARSE_APP_ID', 'X-Parse-Master-Key'=>'PARSE_MASTER_KEY'}).
+        to_return(status: 200, body: { result: true }.to_json, headers: { content_type: 'application/json' })
     end
 
-    context 'with no channels' do
+    context 'with no channels or criteria' do
       let(:channels) { [] }
+      let(:criteria) { nil }
 
       it { expect { result }.to raise_exception( ArgumentError ) }
     end
@@ -79,8 +134,121 @@ describe Opium::Push do
     context 'with channels' do
       let(:channels) { %w{ Penguins PolarBears } }
 
+      it 'sets the channels key' do
+        expect( push_post_data ).to include( channels: channels )
+      end
+      it 'does not set the where key' do
+        expect( push_post_data ).to_not include( :where )
+      end
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to eq true }
+    end
+
+    context 'with a criteria' do
+      let(:channels) { nil }
+      let(:criteria) { { device_type: :ios } }
+
+      it 'does not set the channels key' do
+        expect( push_post_data ).to_not include( :channels )
+      end
+      it 'sets the where key' do
+        expect( push_post_data ).to include( :where )
+      end
+      it 'sets the where key to a parse-friendly version' do
+        expect( push_post_data[:where] ).to eq( { 'deviceType' => :ios } )
+      end
+
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to eq true }
+    end
+
+    context 'with channels and a criteria' do
+      let(:channels) { %w{ Penguins PolarBears } }
+      let(:criteria) { { device_type: :ios } }
+
+      it 'does not set the channels key' do
+        expect( push_post_data ).to_not include( :channels )
+      end
+      it 'sets the where key' do
+        expect( push_post_data ).to include( :where )
+      end
+      it 'adds the channels to the criteria' do
+        expect( push_post_data[:where] ).to include( channels: channels )
+      end
+
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to eq true }
+    end
+
+    context 'with an installation criteria and channels' do
+      let(:channels) { %w{ Penguins PolarBears } }
+      let(:criteria) { Opium::Installation.where( device_type: :ios ).lte( badge: 5 ) }
+
+      it 'does not set the channels key' do
+        expect( push_post_data ).to_not include( :channels )
+      end
+      it 'sets the where key' do
+        expect( push_post_data ).to include( :where )
+      end
+      it 'adds the channels to the criteria' do
+        expect( push_post_data[:where] ).to include( channels: channels )
+      end
+      it 'uses the installation criterias constraints' do
+        expect( push_post_data[:where] ).to include( :badge )
+        expect( push_post_data[:where][:badge] ).to include( '$lte' => 5 )
+      end
+
       it { expect { result }.to_not raise_exception }
       it { expect( result ).to eq true }
     end
+
+    context 'with a scheduled push' do
+      let(:push_at) { one_day_from_now }
+
+      it { expect { push_post_data }.not_to raise_exception }
+      it 'sets the proper push_time' do
+         expect( push_post_data ).to include( push_time: push_at.iso8601 )
+      end
+    end
+
+    context 'with a scheduled push before now' do
+      let(:push_at) { one_day_ago }
+
+      it { expect { result }.to raise_exception( ArgumentError ) }
+    end
+
+    context 'with a scheduled push too long from now' do
+      let(:push_at) { three_weeks_from_now }
+
+      it { expect { result }.to raise_exception( ArgumentError ) }
+    end
+
+    context 'with a scheduled push and an expiration inverval' do
+      let(:push_at) { one_day_from_now }
+      let(:expiration_interval) { one_week }
+
+      it { expect { push_post_data }.not_to raise_exception }
+      it 'sets the proper push_time' do
+        expect( push_post_data ).to include( push_time: push_at.iso8601 )
+      end
+      it 'sets the proper expiration_interval' do
+        expect( push_post_data ).to include( expiration_interval: expiration_interval )
+      end
+    end
+
+    context 'without a scheduled push and with an expiration inverval' do
+      let(:expiration_interval) { one_week }
+
+      it { expect { result }.to raise_exception( ArgumentError ) }
+    end
+
+    context 'with an expiry' do
+      let(:expires_at) { one_week_from_now }
+
+      it { expect { push_post_data }.not_to raise_exception }
+      it 'sets the proper expiration_time' do
+        expect( push_post_data ).to include( expiration_time: expires_at.iso8601 )
+      end
+    end
   end
 end

data/spec/opium_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
 
 describe Opium do
-  it { expect( described_class.constants ).to include( :Model, :User, :File, :Config, :Schema, :Push ) }
+  it { expect( described_class.constants ).to include( :Model, :User, :Installation, :File, :Config, :Schema, :Push ) }
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opium
 version: !ruby/object:Gem::Version
-  version: 1.5.2
+  version: 1.5.3
 platform: ruby
 authors:
 - Joshua Bowers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-28 00:00:00.000000000 Z
+date: 2017-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -252,6 +252,7 @@ files:
 - README.md
 - Rakefile
 - lib/generators/opium/config_generator.rb
+- lib/generators/opium/installation_generator.rb
 - lib/generators/opium/model_generator.rb
 - lib/generators/opium/templates/config.yml
 - lib/generators/opium/templates/model.rb
@@ -277,6 +278,7 @@ files:
 - lib/opium/extensions/time.rb
 - lib/opium/extensions/true_class.rb
 - lib/opium/file.rb
+- lib/opium/installation.rb
 - lib/opium/model.rb
 - lib/opium/model/attributable.rb
 - lib/opium/model/batchable.rb
@@ -324,6 +326,7 @@ files:
 - spec/opium/extensions/symbol_spec.rb
 - spec/opium/extensions/time_spec.rb
 - spec/opium/file_spec.rb
+- spec/opium/installation_spec.rb
 - spec/opium/model/attributable_spec.rb
 - spec/opium/model/batchable/batch_spec.rb
 - spec/opium/model/batchable/operation_spec.rb
@@ -394,6 +397,7 @@ test_files:
 - spec/opium/extensions/symbol_spec.rb
 - spec/opium/extensions/time_spec.rb
 - spec/opium/file_spec.rb
+- spec/opium/installation_spec.rb
 - spec/opium/model/attributable_spec.rb
 - spec/opium/model/batchable/batch_spec.rb
 - spec/opium/model/batchable/operation_spec.rb