spark_api 1.2.1 → 1.3.0

data/lib/spark_api/models/subscription.rb

@@ -1,52 +0,0 @@
-module SparkApi
-  module Models
-
-    class Subscription < Base
-      extend Finders
-      include Concerns::Savable,
-              Concerns::Destroyable
-
-      self.element_name = "subscriptions"
-
-      # list subscribers (private role)
-      def subscribers
-        return {} unless persisted?
-        results = connection.get("#{self.class.path}/#{@attributes["Id"]}/subscribers")
-        @attributes['RecipientIds'] = results.first['RecipientIds']
-        results
-      end
-
-      # subscribe/unsubscribe contact (private role)
-      [:subscribe, :unsubscribe].each do |action|
-        method = (action == :subscribe ? :put : :delete)
-        define_method(action) do |contact|
-          return false unless persisted?
-          self.errors = []
-          contact_id = contact.is_a?(Contact) ? contact.Id : contact
-          begin
-            connection.send(method, "#{self.class.path}/#{@attributes["Id"]}/subscribers/#{contact_id}")
-          rescue BadResourceRequest, NotFound => e
-            self.errors << { :code => e.code, :message => e.message }
-            SparkApi.logger.error("Failed to #{action} contact #{contact}: #{e.message}")
-            return false
-          end
-          update_recipients(action, contact_id)
-          true
-        end
-      end
-
-      private
-
-      def update_recipients(method, contact_id)
-        @attributes['RecipientIds'] = [] if @attributes['RecipientIds'].nil?
-        if method == :subscribe
-          @attributes['RecipientIds'] << contact_id
-        else
-          @attributes['RecipientIds'].delete contact_id
-        end
-      end
-
-    end
-
-  end
-end

data/spec/fixtures/subscriptions/get.json

@@ -1,19 +0,0 @@
-{
-	"D": {
-		"Success": true, 
-		"Results": [
-			{
-                "Id":"20101230223226074204000000",
-				"ResourceUri":"/v1/contacts/20101230223226074204000000",
-                "Name":"First subscription",
-                "RecipientIds": ["20101230223226074307000000"]
-			},
-			{
-                "Id":"20101230223226074205000000",
-				"ResourceUri":"/v1/contacts/20101230223226074205000000",
-                "Name":"Second subscription",
-                "RecipientIds": []
-			}
-		]
-	}
-}

data/spec/fixtures/subscriptions/new.json

@@ -1,13 +0,0 @@
-{
-	"D": {
-        "Subscriptions": [
-            {
-                "Name":"A new subscription name",
-                "SearchId":"20101230223226074204000000",
-                "RecipientIds": ["20101230223226074204000000"],
-                "Subject": "my subject",
-                "Message": "my message"
-            }
-        ]
-	}
-}

data/spec/fixtures/subscriptions/post.json

@@ -1,10 +0,0 @@
-{
-	"D": {
-		"Success": true, 
-		"Results": [
-			{
-				"ResourceUri":"/v1/subscriptions/20101230223226074204000000"
-			}
-		]
-	}
-}

data/spec/fixtures/subscriptions/put.json

@@ -1,12 +0,0 @@
-{
-	"D": {
-		"Success": true, 
-		"Results": [
-			{
-                "Id":"20101230223226074204000000",
-				"ResourceUri":"/v1/contacts/20101230223226074204000000",
-                "Name":"A new subscription name"
-			}
-		]
-	}
-}

data/spec/fixtures/subscriptions/subscribe.json

@@ -1,5 +0,0 @@
-{
-    "D":{
-        "Success":true
-    }
-}

data/spec/fixtures/subscriptions/update.json

@@ -1,6 +0,0 @@
-{
-	"D": {
-        "Name":"A new subscription name"
-	}
-}
-

data/spec/json_hash_test_support.rb

@@ -1,251 +0,0 @@
-# Several workarounds to get our test setup working in multiple ruby environments credit is 
-# attributed to all the projects that found solutions to these test headaches! 
-
-
-module SparkApiTest
-# directly taken from Rails 3.1's OrderedHash
-# see https://github.com/rails/rails/blob/master/activesupport/lib/active_support/ordered_hash.rb
-
-# The order of iteration over hashes in Ruby 1.8 is undefined. For example, you do not know the
-# order in which +keys+ will return keys, or +each+ yield pairs. <tt>ActiveSupport::OrderedHash</tt>
-# implements a hash that preserves insertion order, as in Ruby 1.9:
-#
-#   oh = ActiveSupport::OrderedHash.new
-#   oh[:a] = 1
-#   oh[:b] = 2
-#   oh.keys # => [:a, :b], this order is guaranteed
-#
-# <tt>ActiveSupport::OrderedHash</tt> is namespaced to prevent conflicts with other implementations.
-class OrderedHash < ::Hash #:nodoc:
-  def to_yaml_type
-    "!tag:yaml.org,2002:omap"
-  end
-
-  def encode_with(coder)
-    coder.represent_seq '!omap', map { |k,v| { k => v } }
-  end
-
-  def to_yaml(opts = {})
-    if YAML.const_defined?(:ENGINE) && !YAML::ENGINE.syck?
-      return super
-    end
-
-    YAML.quick_emit(self, opts) do |out|
-      out.seq(taguri) do |seq|
-        each do |k, v|
-          seq.add(k => v)
-        end
-      end
-    end
-  end
-
-  def nested_under_indifferent_access
-    self
-  end
-
-  # Hash is ordered in Ruby 1.9!
-  if RUBY_VERSION < '1.9'
-
-    # In MRI the Hash class is core and written in C. In particular, methods are
-    # programmed with explicit C function calls and polymorphism is not honored.
-    #
-    # For example, []= is crucial in this implementation to maintain the @keys
-    # array but hash.c invokes rb_hash_aset() originally. This prevents method
-    # reuse through inheritance and forces us to reimplement stuff.
-    #
-    # For instance, we cannot use the inherited #merge! because albeit the algorithm
-    # itself would work, our []= is not being called at all by the C code.
-
-    def initialize(*args, &block)
-      super
-      @keys = []
-    end
-
-    def self.[](*args)
-      ordered_hash = new
-
-      if (args.length == 1 && args.first.is_a?(Array))
-        args.first.each do |key_value_pair|
-          next unless (key_value_pair.is_a?(Array))
-          ordered_hash[key_value_pair[0]] = key_value_pair[1]
-        end
-
-        return ordered_hash
-      end
-
-      unless (args.size % 2 == 0)
-        raise ArgumentError.new("odd number of arguments for Hash")
-      end
-
-      args.each_with_index do |val, ind|
-        next if (ind % 2 != 0)
-        ordered_hash[val] = args[ind + 1]
-      end
-
-      ordered_hash
-    end
-
-    def initialize_copy(other)
-      super
-      # make a deep copy of keys
-      @keys = other.keys
-    end
-
-    def []=(key, value)
-      @keys << key unless has_key?(key)
-      super
-    end
-
-    def delete(key)
-      if has_key? key
-        index = @keys.index(key)
-        @keys.delete_at index
-      end
-      super
-    end
-
-    def delete_if
-      super
-      sync_keys!
-      self
-    end
-
-    def reject!
-      super
-      sync_keys!
-      self
-    end
-
-    def reject(&block)
-      dup.reject!(&block)
-    end
-
-    def keys
-      @keys.dup
-    end
-
-    def values
-      @keys.collect { |key| self[key] }
-    end
-
-    def to_hash
-      self
-    end
-
-    def to_a
-      @keys.map { |key| [ key, self[key] ] }
-    end
-
-    def each_key
-      return to_enum(:each_key) unless block_given?
-      @keys.each { |key| yield key }
-      self
-    end
-
-    def each_value
-      return to_enum(:each_value) unless block_given?
-      @keys.each { |key| yield self[key]}
-      self
-    end
-
-    def each
-      return to_enum(:each) unless block_given?
-      @keys.each {|key| yield [key, self[key]]}
-      self
-    end
-
-    alias_method :each_pair, :each
-
-    alias_method :select, :find_all
-
-    def clear
-      super
-      @keys.clear
-      self
-    end
-
-    def shift
-      k = @keys.first
-      v = delete(k)
-      [k, v]
-    end
-
-    def merge!(other_hash)
-      if block_given?
-        other_hash.each { |k, v| self[k] = key?(k) ? yield(k, self[k], v) : v }
-      else
-        other_hash.each { |k, v| self[k] = v }
-      end
-      self
-    end
-
-    alias_method :update, :merge!
-
-    def merge(other_hash, &block)
-      dup.merge!(other_hash, &block)
-    end
-
-    # When replacing with another hash, the initial order of our keys must come from the other hash -ordered or not.
-    def replace(other)
-      super
-      @keys = other.keys
-      self
-    end
-
-    def invert
-      OrderedHash[self.to_a.map!{|key_value_pair| key_value_pair.reverse}]
-    end
-
-    private
-      def sync_keys!
-        @keys.delete_if {|k| !has_key?(k)}
-      end
-  end
-end
-end
-
-# Originally based on a fix found in Koala, a facebook client gem that has compatibile licensing.
-# See: https://raw.github.com/arsduo/koala/master/spec/support/json_testing_fix.rb
-#
-# when testing across Ruby versions, we found that JSON string creation inconsistently ordered keys
-# which is a problem because our mock testing service ultimately matches strings to see if requests are mocked
-# this fix solves that problem by ensuring all hashes are created with a consistent key order every time
-module MultiJson
-
-  class << self
-    def dump_with_ordering(object)
-      # if it's a hash, recreate it with k/v pairs inserted in sorted-by-key order
-      # (for some reason, REE fails if we don't assign the ternary result as a local variable
-      # separately from calling encode_original)
-      dump_original(sort_object(object))
-    end
-
-    alias_method :dump_original, :dump
-    alias_method :dump, :dump_with_ordering
-  
-    def load_with_ordering(string)
-      sort_object(load_original(string))
-    end
-
-    alias_method :load_original, :load
-    alias_method :load, :load_with_ordering
-    
-    private 
-  
-    def sort_object(object)
-      if object.is_a?(Hash)
-        sort_hash(object)
-      elsif object.is_a?(Array)
-        object.collect {|item| item.is_a?(Hash) ? sort_hash(item) : item}
-      else
-        object
-      end
-    end
-  
-    def sort_hash(unsorted_hash)
-      sorted_hash = SparkApiTest::OrderedHash.new(sorted_hash)
-      unsorted_hash.keys.sort {|a, b| a.to_s <=> b.to_s}.inject(sorted_hash) {|hash, k| hash[k] = unsorted_hash[k]; hash}
-    end
-  end
-end
-

data/spec/json_helper.rb

@@ -1,76 +0,0 @@
-class ListingJson
-  @counter = 0
-  def self.next_tech_id()
-    "#{@counter + 20110101000000000000}000000"
-  end
-  def self.next_list_id()
-    "06-#{@counter + 1000}"
-  end
-  def self.bump()
-    @counter += 1
-  end
-  
-  def self.create
-    bump
-    json = <<-JSON 
-      {
-        "ResourceUri": "/v1/listings/#{next_tech_id}",
-        "StandardFields": #{standard_fields},
-        "Id": "#{next_tech_id}"
-      }
-    JSON
-     
-  end
-  
-  def self.create_all(count = 1)
-    listings = []
-    count.times { listings << create }
-    json = listings * ","
-  end
-  
-  private
-  def self.standard_fields
-    json = <<-JSON 
-        {
-          "StreetNumber": "7298",
-          "Longitude": "-116.3237",
-          "City": "Bonners Ferry",
-          "ListingId": "#{next_list_id}",
-          "PublicRemarks": "Afforadable home in town close to hospital,yet quiet country like setting. Good views. Must see",
-          "BuildingAreaTotal": 924.0,
-          "YearBuilt": 1977,
-          "StreetName": "BIRCH",
-          "ListPrice": 50000.0,
-          "PostalCode": 83805,
-          "Latitude": "48.7001",
-          "BathsThreeQuarter": null,
-          "BathsFull": 1.0,
-          "BathsTotal": 1.0,
-          "StateOrProvince": "ID",
-          "PropertyType": "A",
-          "StreetAdditionalInfo": null,
-          "StreetDirPrefix": null,
-          "BedsTotal": 3,
-          "StreetDirSuffix": null,
-          "ListingKey": "#{next_tech_id}",
-          "ListOfficeName": "Century 21 On The Lake",
-          "BathsHalf": null,
-          "ModificationTimestamp": "2010-11-22T20:47:21Z",
-          "CountyOrParish": "Boundary"        
-        }
-    JSON
-  end
-
-end
-
-def paginate_json(current_page = 1)
-  json = <<-JSON 
-    "Pagination": {
-      "TotalRows": 38,
-      "PageSize": 10,
-      "TotalPages": 4,
-      "CurrentPage": #{current_page}
-    }
-  JSON
-end
-