opium 1.3.5 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ba3e984219298d9044d897b69174d070e97203ea
-  data.tar.gz: a75539396c4cf16ce7663a6cb2aa0014cf7a5284
+  metadata.gz: f2703590e11e240c7ad03f62e04a0c19ff0cdf11
+  data.tar.gz: 139dac0e475494014a9996e417d2332705aba373
 SHA512:
-  metadata.gz: 01cb3c6a85d9b7164453c422ce2c760a0f30fe16d5130275acc95499e9684c7d7aaeedb39df18241752609c150fd2a5a8bed52f1e5bdb476d06f0ff96d2f3269
-  data.tar.gz: 0592a85febebccaae06eb14d3688d3cb33809d6ba185ff481b76b54c6c9b57f26726f53509e16ac4a763420a60390e9bf5716671a90519873c31849056fb43c4
+  metadata.gz: 81e4d0868f9e80dc8d08412bcf4b54ca67007d39bfb17c10a77ae9997fa4f7822775f9c6bc3e0ba5ae951c9bb22291fadca78529adb4602c8d9c8620ac0a7f10
+  data.tar.gz: 340904910c91a3a50f7a1d38420cddca627653aca189507af4240fdb524ae545f98e5427e6c17c4c203b22898023a5a774c61a5d30a565525e72f6a8dde7ed85

data/.travis.yml

@@ -2,10 +2,10 @@ language: ruby
 cache: bundler
 
 rvm:
-  - 1.9.3
   - 2.0.0
   - 2.1.2
   - 2.2.0
+  - 2.3.1
 
 before_install:
   - gem update bundler

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 1.4.0
+### New Features
+- #52: Opium should now be capable of easily connecting to a custom parse-server instance hosted on a third party server.
+
 ## 1.3.5
 ### New Features
 - Due to ignorance, missed a method override for Opium::GeoPoint ===. Now implemented at the class level as well as at the instance level.

data/README.md

@@ -37,7 +37,18 @@ $ rails g opium:config
 
 See the generated file at `config/opium.yml` for more details
 
-#### Model Generator
+### Parse.com server closure note
+
+Opium was originally written to communicate with apps hosted on Parse.com; as hosted parse is hitting end-of-life in January 2017, any parse apps which wish to continue using the infrastructure need to be [migrated to third-party hosted parse-server instance](https://www.parse.com/migration).
+
+As of version 1.4.0, Opium should be able to communicate with these third-party installations. Within the generated configuration file, two settings need to be updated to point Opium at the proper server instance:
+
+- `server_url`: the URL of the server on which a parser-server API instance is hosted.
+- `mount_point`: the sub-URI endpoint on `server_url` where Opium can reach the API.
+
+As the config file suggests, it is suggested that these values be provided in a server environment via environment variables.
+
+### Model Generator
 
 A generator exists for creating new models; this should be invoked whenever `rails g model` gets invoked.
 
@@ -45,6 +56,12 @@ 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:
+
+```bash
+$ rails g opium:user
+```
+
 ### Specifying a model
 
 Models are defined by mixing in `Opium::Model` into a new class. Class names should match the names of the
@@ -54,7 +71,7 @@ class.
 ```ruby
 class Game
   include Opium::Model
-  
+
   field :title, type: String
   field :price, type: Float
 end
@@ -63,6 +80,324 @@ end
 All models automatically come with three fields: *:id*, *:created_at*, and *:updated_at*. Field names are
 converted from a native ruby snake_case naming convention to a Parse lowerCamel convention.
 
+#### Field data types
+
+Opium comes with support for a variety of different data types for fields. These automatically will convert native ruby representations of the stored values to values supported by the parse backend, and conversely. At this time, Opium supports the following field types, where the first column is the type specified in ruby, and the second column is the type as stored in parse.
+
+| Ruby Type       | Parse Type |
+|-----------------|------------|
+| Integer         | Number     |
+| Float           | Number     |
+| String          | String     |
+| Symbol          | String     |
+| Date            | Date       |
+| DateTime        | Date       |
+| Time            | Date       |
+| Array           | Array      |
+| Opium::Boolean  | Boolean    |
+| Opium::GeoPoint | GeoPoint   |
+| Opium::File     | File       |
+| Opium::Pointer  | Pointer    |
+
+Field setters will generally attempt to convert any incoming value to a native ruby representation, as noted above. Opium will automatically convert these values to a parse-friendly representation as necessary: e.g., when performing a query or persisting data.
+
+Setting the type for a field is done by specifying the `:type` option on the field method. If this option is not present, the field will default to a ruby type of `Object`, which acts as a pass-through of the values coming from and going to parse. In the example from the last section, the `Game` model has two fields, one which is specified as having a `String` type, while the other has a `Float` type.
+
+#### Field options
+
+Fields can be modified by a small set of options passed to their definition:
+
+- `readonly`: Expects a boolean value. If present, Opium will prevent the field from being altered locally. (The associated parse column may still be modified from other locations outside of Opium.)
+- `as`: Expects a string or symbol value. If present, this will specify the name of the associated column within parse where the value should be stored. This allows the field to be named something more semantically useful locally.
+- `type`: See the previous section. Expects a class constant.
+- `default`: Expects either a logically convertible literal or a lambda providing the same. If a lambda is provided, it will be evaluated each time a model is instantiated, unless a value is provided for the field.
+
+```ruby
+class Article
+  include Opium::Model
+
+  field :title, type: String, readonly: true
+  field :edited_on, type: Date, as: :last_edited
+  field :published_at, type: Date, default: -> { Time.now }
+end
+```
+
+In the preceding example, an `Article` is never allowed to alter its `title`, while its `last_edited` field is locally aliased as `edited_on`, and it will provide a default value for `published_at`, should none otherwise be provided.
+
+#### Model associations
+
+Opium currently supports basic associations between models: an owning model can specify that it `has_many` of another model, which can specify that it `belongs_to` the former.
+
+```ruby
+class Player
+  # ...
+  has_many :high_scores
+  # ...
+end
+
+class HighScore
+  # ...
+  belongs_to :player
+  # ...
+end
+```
+
+Opium will attempt to infer the class name and inverse method of an association by standard Rails naming conventions: the singular, classified variant of the method name is taken to be the target class. In case naming conventions prohibit this inference from working properly, the following options are available:
+
+- `class_name`: Expects a string. In case the class name cannot be inferred from the association name, it can be provided by this option.
+- `inverse_of`: Expects a string or a symbol. In case the inverse method name cannot be inferred from the association name or its class name, it can be provided by this option.
+
+Associations will be covered in more detail in the sections covering [creating models](#creating-and-updating-models) and [querying data](#querying-data). For now, note that Opium will attempt to manage the relationships between associated models for you and provides a robust, Rails-centric approach to manipulating and querying them.
+
+#### Model field metadata
+
+A set of utility class methods are provided to survey the defined fields and associations on any given model:
+
+- `#fields`: returns a hash of all defined fields, keyed by the name of the field. Each value stored within the hash is an [`Opium::Model::Field`](lib/opium/model/field.rb) object, which has methods which reflect the settings discussed in [Field options](#field-options).
+- `#has_field?` / `#field?`: expects a string or symbol, and returns a boolean value denoting whether the field is currently defined on the model.
+- `#relations`: returns a hash of all defined associations, keyed by the method name used to define the relationship on the current model. Each value is a [`Opium::Model::Relatable::Metadata`](lib/opium/model/relatable/metadata.rb), which contains details pertaining to what the association is being made between.
+
+Each of these methods would be called on the model you wish to inspect. In the following example, we ask the `Player` model if it has a `:name` field, get all of its readonly fields, and grab a list of its associations:
+
+```ruby
+class Player
+  include Opium::Model
+  field :name, type: String
+  field :gamer_score, type: Integer
+  has_many :high_scores
+  has_many :played_games, class_name: 'GameSave', inverse_of: :played_by
+end
+
+# Should output the message, as Player does define a field called "name"
+puts "'Player' has a name field!" if Player.has_field? :name
+
+# Winnows the collection of field definitions by selecting only those which are readonly.
+readonly_fields = Player.fields.select {|_, field| field.readonly?}
+
+# #relations is a hash, indexed by name; in this example, the output should include the text "high_scores, played_games".
+puts "'Player' defines the following associations: #{ Player.relations.keys.join(', ') }"
+```
+
+Model metadata is readonly; it shouldn't be updated after the model has been defined. It might be useful, however, for writing model concerns or some sort of view decorator to help DRY up model usage in Rails.
+
+#### Validations
+
+Opium provides access to `ActiveModel::Validations` on a per model basis, so it is possible to validate the integrity of any data stored within an instance prior to saving it. Validations follow the normal ActiveModel format:
+
+```ruby
+class Article
+  include Opium::Model
+  field :title, type: String
+  # ...
+  validates :title, presence: true
+end
+
+article = Article.new
+article.valid?       # false, as .title is nil.
+article.errors       # Standard ActiveModel::Errors object
+article.title = 'Wibbly Wobbly Timey Wimey'
+article.valid?       # true, as .title has a value.
+```
+
+As is standard with `ActiveModel` compliant libraries, attempting to save an invalid model will either return false (and not trigger the save) or raise an exception, depending upon how the save was triggered.
+
+#### Callback hooks
+
+Each Opium model has a set of callback points which can be hooked into. Adhering to the standard of `ActiveModel::Callbacks`, these provide a model a means by which to tie into various parts of an instance's lifecycle.
+
+A full list of the available callbacks can be found by accessing the following constant:
+
+```ruby
+Opium::Model::Callbacks::CALLBACKS
+```
+
+Opium defines callbacks for the following events:
+
+| Event / Action | Supported hooks       |
+|----------------|-----------------------|
+| Save           | before, after, around |
+| Create         | before, after, around |
+| Update         | before, after, around |
+| Destroy        | before, after, around |
+| Initialize     | after                 |
+| Find           | after                 |
+| Touch          | after                 |
+| Validation     | before, after         |
+
+To define a callback, do something like in the following example. (This example uses Dirty attributes, which are discussed in the next section.)
+
+```ruby
+class Game
+  # ...
+  field :price, type: Float
+  has_many :on_wishlists, class_name: Wishlist
+  # ...
+
+  before_save :notify_price_drop
+
+  private
+
+  def notify_price_drop
+    if price_changed? && price_was > price
+      # Send a message to all players who have the game on their wishlist ...
+    end
+  end
+end
+```
+
+Please note that callbacks are only invokable within the context of Opium running in Ruby itself; these do not define Cloud Code JavaScript methods within the parse-server backend. If you need to tie into an instance's lifecycle outside the scope of a Ruby project, it is suggested that you look at using Cloud Code directly.
+
+#### Dirty attribute tracking
+
+Models will automatically gain attribute tracking, provided by `ActiveModel::Dirty`. As the fields of a model are altered, specialty events, of the form `<field-name>_will_change!` will be raised. At any point prior to saving, you can use the full suite of Dirty methods to query an instance about changes which have occurred to it. Dirty tracking follows a cycle: upon instance initialization, the model has no changes; upon a field changing, the current set of changes is updated; upon successfully saving the model, the current changes are cleared, and the previous changes get updated.
+
+```ruby
+class Article
+  include Opium::Model
+  field :title, type: String
+  field :body, type: String
+end
+
+article = Article.new
+article.changes        # Should be empty
+
+# As we are updating the .title, it'll flag the dirty tracking with its update;
+# as it has changed, some output denoting the alteration should be made.
+article.title = 'Something happen'
+puts article.title_change.inspect if article.title_changed?
+```
+
+Dirty tracking is provided for any attribute defined by the [`field`](#specifying-a-model) method.
+
+#### JSON serialization
+
+All Opium models should be serializable to JSON, using `ActiveModel::Serialization`. Note that a model instance does not include a root node.
+
+JSON serialization is built around an object's `attributes` hash, which is publicly accessible. By default, all fields of the model are included within this hash. You can also store non-field data within `attributes` and have it show up in the JSON output.
+
+Be aware that all Opium models use `ActiveModel::ForbiddenAttributesProtection` for mass assignment sanitization.
+
+### Creating and updating models
+
+After defining a model with Opium, you might want to create new instances of it, or update the data of an existing instance. Opium has been designed to be familiar to anyone who has used other Rails-centric ORMs, such as ActiveRecord. In this regard, object creation follows two patterns: delayed persistence, and immediate persistence.
+
+With delayed persistence, a model object is partially built and capable of being manipulated before being persisted. To finally create the model in parse-server, call its `save` method:
+
+```ruby
+class Player
+  include Opium::Model
+  field :name, type: String
+  field :gamer_score, type: Integer, default: 0
+end
+
+player = Player.new( name: 'The Doctor' )
+player.gamer_score = 1000
+
+player.persisted?     # false, as it has not yet been saved
+player.new_record?    # true, as it has not yet been saved
+
+if player.save
+  # persisted!  
+  player.persisted?   # true, as it has been saved
+else
+  # there was a problem!
+end
+```
+
+As this example suggests, you build a new model instance by calling its constructor, which accepts an attributes hash. The model may be altered and updated to taste. When ready to save, call the `save` method. `save` will run validations on the model, fire off any defined callbacks, update dirty tracking, and attempt to persist the model to parse-server. Should any of these steps fail, `save` will return false, and halt the operation at the point of failure. Otherwise, `save` will return true.
+
+Alternatively, you can use `save!`, which, in the event of a failure, will raise an exception.
+
+Note that the model's `id`, `created_at`, and `updated_at` fields will not have a value until it has been persisted.
+
+With immediate persistence, a model object is built and then immediately stored to parse-server. This is achieved using the `create` class method, which accepts an attributes hash:
+
+```ruby
+player = Player.create( name: 'The Doctor', gamer_score: 1000 )
+player.persisted?     # true, as it has been saved
+```
+
+`create` behaves like `save!`: if there was a failure at any point in the persistence process, an exception will be raised. If there is no failure, the object returned by the method is a persisted model within parse-server.
+
+Updating a model follows a similar set of patterns: at any time you wish to store changes to a persisted model, call `save` or `save!`:
+
+```ruby
+player.gamer_score += 50
+player.save!
+```
+
+Alternatively, if you want to update the attributes of a model and save it simultaneously, you can do so with either `update` or `update!`, which behave analogously to the save methods:
+
+```ruby
+if player.update( gamer_score: player.gamer_score + 50 )
+  # persisted!
+else
+  # There was a problem!
+end
+
+player.update!( gamer_score: 2000 )
+```
+
+`update` is aliased as `update_attributes`, and `update!` is aliased as `update_attributes!`; use whichever makes more semantic sense to you.
+
+If a model has any associations, it will attempt to persist the changes to the association, which might very well cause a cascade of persistence. Opium will attempt to only trigger a save call to a model if it needs to. Due to parse-server's unique way of representing model associations in its API, updating the association between two models does require a separate API call. Be wary when attempting to modify many models simultaneously.
+
+When you define an association between two models, one of those models receives a special collection field of type `Opium::Model::Relation` for storing instances of the other model. This collection has utility methods for building new instances of the associated model:
+
+```ruby
+class Player
+  # ...
+  has_many :high_scores
+  # ...
+end
+
+class HighScore
+  # ...
+  belongs_to :player
+  # ...
+end
+
+player = Player.new
+player.high_scores.class     # Opium::Model::Relation
+player.high_scores.count     # 0, as there are none, yet.
+
+score1 = player.high_scores.build
+score1.value = 200
+
+# .build is aliased as .new; either accepts an attributes hash.
+score2 = player.high_scores.new( value: 1000 )
+
+player.high_scores.count     # 2, from the previous actions
+
+fail "That shouldn't have happened" unless score1.player == player
+```
+
+As you might expect, using a relation's build method will automatically add the built associated model to the collection; using this method will also cause the built model to point at the owner of the collection. You can also update the owner of a particular model on that model directly:
+
+```ruby
+score3 = HighScore.new( value: 10000 )
+score3.player = player
+
+player.high_scores.include?( score3 )   # true, as the above setter updates player.
+```
+
+### Querying data
+
+#### Find by id
+
+#### Criteria & Scopes
+
+#### Kaminari support
+
+Opium comes with support for [Kaminari](https://rubygems.org/gems/kaminari). To ensure that Opium loads itself correctly, please specify it _after_ Kaminari within your Gemfile:
+
+```Gemfile
+gem 'kaminari'
+gem 'opium'
+```
+
+Models and Criteria will gain the methods defined by Kaminari, and should be compatible with Kaminari's pagination partials.
+
 ## Contributing
 
 1. Fork it ( https://github.com/[my-github-username]/opium/fork )

data/lib/generators/opium/templates/config.yml

@@ -1,25 +1,37 @@
 development:
   # The Application ID for your Parse app. Mandatory
   app_id: PARSE-APP-ID
-    
+
   # The REST API key for your Parse app. Mandatory
   api_key: PARSE-API-KEY
-    
-  # Your Parse app's master key setting. You may omit this, 
-  # but you will be unable to edit Users except by ACL rules
+
+  # Your Parse app's master key setting. You may omit this,
+  # but you will be unable to edit Users except by ACL rules.
   master_key: PARSE-MASTER-KEY
-  
+
   # You can store your app's webhook key here; Opium currently does not use this.
   webhook_key: PARSE-WEBHOOK-KEY
-    
+
+  # The URL of the server where the parse API is available. For hosted parse, this
+  # should be https://api.parse.com; for a parse-server installation, this will be
+  # whatever server the instance is running on.
+  server_url: https://api.parse.com
+
+  # The sub-URI on :server_url where the parse-server API is available. For hosted
+  # parse, this should be /1; for a default parse-server-example installation, this
+  # defaults to /parse.
+  mount_point: /1
+
   # Any communications done with parse will either be (true) displayed or (false) silenced
   log_network_responses: false
-    
+
 test:
   app_id: PARSE-TEST-APP-ID
   api_key: PARSE-TEST-API-KEY
   master_key: PARSE-TEST-MASTER-KEY
   webhook_key: PARSE-TEST-WEBHOOK-KEY
+  server_url: https://api.parse.com
+  mount_point: /1
   log_network_responses: true
 
 # You could hardcode the values for the production Parse app here, but it is suggested
@@ -29,4 +41,6 @@ production:
   api_key: <%= ENV['PARSE_API_KEY'] %>
   master_key: <%= ENV['PARSE_MASTER_KEY'] %>
   webhook_key: <%= ENV['PARSE_WEBHOOK_KEY'] %>
-  log_network_responses: false
+  server_url: <%= ENV['PARSE_SERVER_URL'] %>
+  mount_point: <%= ENV['PARSE_MOUNT_POINT'] %>
+  log_network_responses: false

data/lib/opium/config.rb

@@ -1,6 +1,6 @@
 module Opium
   extend self
-  
+
   def configure
     yield config
   end
@@ -8,7 +8,7 @@ module Opium
   def config
     @config ||= Opium::Config.new
   end
-  
+
   def load!( path, environment = nil )
     settings = load_yaml( path, environment )
     configure do |config|
@@ -17,11 +17,11 @@ module Opium
       end
     end
   end
-  
+
   def reset
     @config = nil
   end
-  
+
   private
 
   def load_yaml( path, environment = nil )
@@ -32,14 +32,16 @@ module Opium
   def env_name
     defined?( Rails ) ? Rails.env : ( ENV["RACK_ENV"] || ENV["OPIUM_ENV"] || raise( "Could not determine environment" )  )
   end
-    
+
   class Config
     include ActiveSupport::Configurable
-    
+
     config_accessor( :app_id ) { 'PARSE_APP_ID' }
     config_accessor( :api_key ) { 'PARSE_API_KEY' }
     config_accessor( :master_key ) { 'PARSE_MASTER_KEY' }
     config_accessor( :webhook_key ) { 'PARSE_WEBHOOK_KEY' }
     config_accessor( :log_network_responses ) { false }
+    config_accessor( :server_url ) { 'https://api.parse.com' }
+    config_accessor( :mount_point ) { '/1' }
   end
-end
+end

data/lib/opium/model/connectable.rb

@@ -19,8 +19,12 @@ module Opium
       end
 
       module ClassMethods
+        def parse_server_url
+          ::URI.join( ::Opium.config.server_url, ::Opium.config.mount_point ).to_s
+        end
+
         def connection
-          @@connection ||= Faraday.new( url: 'https://api.parse.com/1/' ) do |faraday|
+          @@connection ||= Faraday.new( url: parse_server_url ) do |faraday|
             faraday.request :multipart
             faraday.request :url_encoded
             faraday.request :json

data/lib/opium/version.rb

@@ -1,3 +1,3 @@
 module Opium
-  VERSION = "1.3.5"
+  VERSION = "1.4.0"
 end

data/opium.gemspec

@@ -6,7 +6,7 @@ require 'opium/version'
 Gem::Specification.new do |spec|
   spec.name          = "opium"
   spec.version       = Opium::VERSION
-  spec.required_ruby_version = '>= 1.9.3'
+  spec.required_ruby_version = '>= 2.0.0'
   spec.authors       = ["Joshua Bowers"]
   spec.email         = ["joshua.bowers+code@gmail.com"]
   spec.summary       = %q{An Object Parse.com Mapping technology for defining models.}

data/spec/opium/config/opium.yml

@@ -3,4 +3,6 @@ test:
   api_key: efgh5678
   master_key: 9012ijkl
   webhook_key: mnop7654
-  log_network_responses: true
+  log_network_responses: true
+  server_url: https://example.com
+  mount_point: /parse

data/spec/opium/config_spec.rb

@@ -1,60 +1,68 @@
 require 'spec_helper'
 
 describe Opium do
-  it { should respond_to(:configure, :config) }
-  it { should respond_to(:load!).with(2).arguments }
-  it { should respond_to(:reset) }
-  
-  describe ':configure' do
+  it { is_expected.to respond_to( :configure, :config ) }
+  it { is_expected.to respond_to( :load! ).with(2).arguments }
+  it { is_expected.to respond_to( :reset ) }
+
+  describe '.configure' do
     it do
       expect {|b| Opium.configure(&b) }.to yield_with_args
     end
   end
-  
-  describe ':config' do
+
+  describe '.config' do
     subject { Opium.config }
-    
-    it { should_not be_nil }
-    it { should be_an( Opium::Config ) }
+
+    it { is_expected.to_not be_nil }
+    it { is_expected.to be_an( Opium::Config ) }
   end
-  
-  describe ':reset' do
+
+  describe '.reset' do
     after { described_class.config.log_network_responses = false }
-    
+
     it 'should put all changed settings back to their defaults' do
       expect { described_class.config.log_network_responses = true }.to change( described_class.config, :log_network_responses ).from( false ).to( true )
       described_class.reset
       described_class.config.log_network_responses.should == false
     end
   end
-  
-  describe ':load!' do
+
+  describe '.load!' do
     let(:file) { File.join( File.dirname( __FILE__ ), 'config', 'opium.yml' ) }
-  
+
     before do
       described_class.load!( file, :test )
     end
-    
+
     after do
       described_class.reset
     end
-  
-    it { subject.config.app_id.should == 'abcd1234' }
-    it { subject.config.api_key.should == 'efgh5678' }
-    it { subject.config.master_key.should == '9012ijkl' }
-    it { subject.config.webhook_key.should == 'mnop7654' }
-    it { subject.config.log_network_responses.should == true }
+
+    subject(:config) { described_class.config }
+
+    context 'a valid config file' do
+      it { expect( config.app_id ).to eq 'abcd1234' }
+      it { expect( config.api_key ).to eq 'efgh5678' }
+      it { expect( config.master_key ).to eq '9012ijkl' }
+      it { expect( config.webhook_key ).to eq 'mnop7654' }
+      it { expect( config.log_network_responses ).to eq true }
+      it { expect( config.server_url ).to eq 'https://example.com' }
+      it { expect( config.mount_point ).to eq '/parse' }
+    end
   end
-    
+
   describe Opium::Config do
-    it { is_expected.to respond_to( :app_id, :api_key, :master_key, :webhook_key, :log_network_responses ) }
-    
-    describe 'defaults' do
-      its(:app_id) { should == 'PARSE_APP_ID' }
-      its(:api_key) { should == 'PARSE_API_KEY' }
-      its(:master_key) { should == 'PARSE_MASTER_KEY' }
-      its(:webhook_key) { should == 'PARSE_WEBHOOK_KEY' }
-      its(:log_network_responses) { should == false }
+    it { is_expected.to respond_to( :app_id, :api_key, :master_key, :webhook_key, :log_network_responses, :server_url, :mount_point ) }
+
+    context 'a default config' do
+      it { expect( subject.app_id ).to eq 'PARSE_APP_ID' }
+      it { expect( subject.api_key ).to eq 'PARSE_API_KEY' }
+      it { expect( subject.master_key ).to eq 'PARSE_MASTER_KEY' }
+      it { expect( subject.webhook_key ).to eq 'PARSE_WEBHOOK_KEY' }
+      it { expect( subject.log_network_responses ).to eq false }
+      it { expect( subject.server_url ).to eq 'https://api.parse.com' }
+      it { expect( subject.mount_point ).to eq '/1' }
     end
   end
-end
+end