spark_api 1.0.2 → 1.0.4

data/lib/spark_api/primary_array.rb~

@@ -1,29 +0,0 @@
-module FlexmlsApi
-  class PrimaryArray < Array
-    
-    def primary
-      find_primary
-    end
-
-    private 
-    
-    # This is a very simplistic but reliable implementation.
-    def find_primary
-      self.each do |arg|
-        if arg.primary?
-          return arg
-        end
-      end
-      nil
-    end
-  end
-  
-  #=== Primary: interface to implement for elements that are added to a "PrimaryArray" collection
-  module Primary
-    # Return true if the element is the primary resource in a collection.
-    # Default implementation looks for a "Primary" attribute
-    def primary?
-      @attributes.key?("Primary") && self.Primary == true
-    end
-  end
-end

data/lib/spark_api/request.rb~

@@ -1,96 +0,0 @@
-require 'cgi'
-
-module FlexmlsApi
-  # HTTP request wrapper.  Performs all the api session mumbo jumbo so that the models don't have to.
-  module Request
-    # Perform an HTTP GET request
-    # 
-    # * path - Path of an api resource, excluding version and endpoint (domain) information
-    # * options - Resource request options as specified being supported via and api resource
-    # :returns:
-    #   Hash of the json results as documented in the api.
-    # :raises:
-    #   FlexmlsApi::ClientError or subclass if the request failed.
-    def get(path, options={})
-      request(:get, path, nil, options)
-    end
-
-    # Perform an HTTP POST request
-    # 
-    # * path - Path of an api resource, excluding version and endpoint (domain) information
-    # * body - Hash for post body data
-    # * options - Resource request options as specified being supported via and api resource
-    # :returns:
-    #   Hash of the json results as documented in the api.
-    # :raises:
-    #   FlexmlsApi::ClientError or subclass if the request failed.
-    def post(path, body={}, options={})
-      request(:post, path, body, options)
-    end
-
-    # Perform an HTTP PUT request
-    # 
-    # * path - Path of an api resource, excluding version and endpoint (domain) information
-    # * body - Hash for post body data
-    # * options - Resource request options as specified being supported via and api resource
-    # :returns:
-    #   Hash of the json results as documented in the api.
-    # :raises:
-    #   FlexmlsApi::ClientError or subclass if the request failed.
-    def put(path, body={}, options={})
-      request(:put, path, body, options)
-    end
-
-    # Perform an HTTP DELETE request
-    # 
-    # * path - Path of an api resource, excluding version and endpoint (domain) information
-    # * options - Resource request options as specified being supported via and api resource
-    # :returns:
-    #   Hash of the json results as documented in the api.
-    # :raises:
-    #   FlexmlsApi::ClientError or subclass if the request failed.
-    def delete(path, options={})
-      request(:delete, path, nil, options)
-    end
-    
-    private
-
-    # Perform an HTTP request (no data)
-    def request(method, path, body, options)
-      unless authenticated?
-        authenticate
-      end
-      attempts = 0
-      begin
-        request_opts = {}
-        request_opts.merge!(options)
-        post_data = body.nil? ? nil : {"D" => body }.to_json
-        request_path = "/#{version}#{path}"
-        start_time = Time.now
-        FlexmlsApi.logger.debug("#{method.to_s.upcase} Request:  #{request_path}")
-        if post_data.nil?
-          response = authenticator.request(method, request_path, nil, request_opts)
-        else
-          FlexmlsApi.logger.debug("#{method.to_s.upcase} Data:   #{post_data}")
-          response = authenticator.request(method, request_path, post_data, request_opts)
-        end
-        request_time = Time.now - start_time
-        FlexmlsApi.logger.info("[#{(request_time * 1000).to_i}ms] Api: #{method.to_s.upcase} #{request_path}")
-      rescue PermissionDenied => e
-        if(ResponseCodes::SESSION_TOKEN_EXPIRED == e.code)
-          unless (attempts +=1) > 1
-            FlexmlsApi.logger.debug("Retrying authentication")
-            authenticate
-            retry
-          end
-        end
-        # No luck authenticating... KABOOM!
-        FlexmlsApi.logger.error("Authentication failed or server is sending us expired tokens, nothing we can do here.")
-        raise
-      end
-      response.body
-    end
-    
-  end
- 
-end

data/lib/spark_api/response.rb~

@@ -1,70 +0,0 @@
-module FlexmlsApi
-  # API Response interface
-  module Response
-    ATTRIBUTES = [:code, :message, :results, :success, :pagination, :details]
-    attr_accessor *ATTRIBUTES
-    def success?
-      @success
-    end
-  end
-  
-  # All known response codes listed in the API
-  module ResponseCodes
-    NOT_FOUND = 404
-    METHOD_NOT_ALLOWED = 405
-    INVALID_KEY = 1000
-    DISABLED_KEY = 1010
-    API_USER_REQUIRED = 1015
-    SESSION_TOKEN_EXPIRED = 1020
-    SSL_REQUIRED = 1030
-    INVALID_JSON = 1035
-    INVALID_FIELD = 1040
-    MISSING_PARAMETER = 1050
-    INVALID_PARAMETER = 1053
-    CONFLICTING_DATA = 1055
-    NOT_AVAILABLE= 1500
-    RATE_LIMIT_EXCEEDED = 1550
-  end
-  
-  # Errors built from API responses
-  class InvalidResponse < StandardError; end
-  class ClientError < StandardError
-    attr_reader :code, :status, :details
-    def initialize (options = {})
-      # Support the standard initializer for errors
-      opts = options.is_a?(Hash) ? options : {:message => options.to_s}
-      @code = opts[:code]
-      @status = opts[:status]
-      @details = opts[:details]
-      super(opts[:message])
-    end
-    
-  end
-  class NotFound < ClientError; end
-  class PermissionDenied < ClientError; end
-  class NotAllowed < ClientError; end
-  class BadResourceRequest < ClientError; end
-  
-  # Nice and handy class wrapper for the api response hash
-  class ApiResponse < ::Array
-    include FlexmlsApi::Response
-    def initialize(d)
-      begin
-        hash = d["D"]
-        if hash.nil? || hash.empty?
-          raise InvalidResponse, "The server response could not be understood"
-        end
-        self.message    = hash["Message"]
-        self.code       = hash["Code"]
-        self.results    = Array(hash["Results"])
-        self.success    = hash["Success"]
-        self.pagination = hash["Pagination"]
-        self.details    = hash["Details"] || []
-        super(results)
-      rescue Exception => e
-        FlexmlsApi.logger.error "Unable to understand the response! #{d}"
-        raise
-      end
-    end
-  end
-end

data/lib/spark_api/version.rb~

@@ -1,4 +0,0 @@
-# Gem version information
-module FlexmlsApi
-  VERSION = File.read(File.dirname(__FILE__) + "/../../VERSION").chomp
-end

data/script/console~

@@ -1,6 +0,0 @@
-#!/usr/bin/env ruby
-# File: script/console
-
-require File.dirname(__FILE__) + '/../lib/flexmls_api/cli'
-ENV["FLEXMLS_API_CONSOLE"] = "true"
-FlexmlsApi::CLI::ConsoleCLI.execute(STDOUT, ARGV)

data/script/example.rb~

@@ -1,27 +0,0 @@
-#!/usr/bin/env ruby
-require "rubygems"
-
-Bundler.require(:default, "development") if defined?(Bundler)
-
-path = File.expand_path(File.dirname(__FILE__) + "/../lib/")
-$LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
-require path + '/flexmls_api'
-
-FlexmlsApi.logger.info("Hello!")
-
-FlexmlsApi.configure do |config|
-  config.api_key = "agent_key"
-  config.api_secret = "agent_secret"
-  config.version = "v1"
-  config.endpoint = "https://api.flexmls.com"
-end
-
-client = FlexmlsApi.client
-
-list = client.get '/contacts'
-puts "client: #{list.inspect}"
-list = FlexmlsApi::Models::Contact.get
-puts "model: #{list.inspect}"
-
-
-

data/spec/unit/flexmls_api_spec.rb~

@@ -1,23 +0,0 @@
-require './spec/spec_helper'
-
-describe FlexmlsApi do
-  after(:each) do
-    reset_config
-  end
-
-  it "should load the version" do
-    subject::VERSION.should match(/\d+\.\d+\.\d+/)
-  end
-
-  it "should give me a client connection" do
-    subject.client.should be_a(FlexmlsApi::Client)
-  end
-
-  it "should reset my connection" do
-    c1 = subject.client
-    subject.reset
-    subject.client.should_not eq(c1)
-  end
-
-end
-

data/spec/unit/spark_api/authentication/api_auth_spec.rb~

@@ -1,169 +0,0 @@
-require './spec/spec_helper'
-
-describe FlexmlsApi::Authentication::ApiAuth  do
-  subject {FlexmlsApi::Authentication::ApiAuth.new(nil) }
-  describe "build_param_hash" do
-    it "should return a blank string when passed nil" do
-      subject.build_param_string(nil).should be_empty
-    end
-    it "should return a correct param string for one item" do
-      subject.build_param_string({:foo => "bar"}).should match("foobar")
-    end
-    it "should alphabatize the param names by key first, then by value" do
-      subject.build_param_string({:zoo => "zar", :ooo => "car"}).should match("ooocarzoozar")
-      subject.build_param_string({:Akey => "aValue", :aNotherkey => "AnotherValue"}).should 
-           match "AkeyaValueaNotherkeyAnotherValue"
-    end
-  end
-  
-  describe "authenticate" do
-    let(:client) { FlexmlsApi::Client.new({:api_key => "my_key", :api_secret => "my_secret"}) }
-    subject do
-      s = FlexmlsApi::Authentication::ApiAuth.new(client)
-      client.authenticator = s
-      s
-    end
-    it "should authenticate the api credentials" do
-      stub_request(:post, "https://api.flexmls.com/#{FlexmlsApi.version}/session").
-                  with(:query => {:ApiKey => "my_key", :ApiSig => "c731cf2455fbc7a4ef937b2301108d7a"}).
-                  to_return(:body => fixture("session.json"))
-      subject.authenticate()
-    end
-    it "should raise an error when api credentials are invalid" do
-      stub_request(:post, "https://api.flexmls.com/#{FlexmlsApi.version}/session").
-                  with(:query => {:ApiKey => "my_key", :ApiSig => "c731cf2455fbc7a4ef937b2301108d7a"}).
-                  to_return(:body => fixture("authentication_failure.json"), :status=>401)
-      expect {subject.authenticate()}.to raise_error(FlexmlsApi::ClientError){ |e| e.status.should == 401 }
-    end
-  end
-
-  describe "authenticated?" do
-    let(:session) { Object.new }
-    it "should return true when session is active" do
-      subject.session = session
-      session.stub(:expired?) { false }
-      subject.authenticated?.should eq(true)
-    end
-    it "should return false when session is expired" do
-      subject.session = session
-      session.stub(:expired?) { true }
-      subject.authenticated?.should eq(false)
-    end
-    it "should return false when session is uninitialized" do
-      subject.authenticated?.should eq(false)
-    end
-  end
-
-  describe "logout" do
-    let(:session) { mock_session }
-    let(:client) { Object.new }
-    subject {FlexmlsApi::Authentication::ApiAuth.new(client) }
-    it "should logout when there is an active session" do
-      logged_out = false
-      subject.session = session
-      client.stub(:delete).with("/session/1234") { logged_out = true }
-      subject.logout
-      subject.session.should eq(nil)
-      logged_out.should eq(true)
-    end
-    it "should skip logging out when there is no active session information" do 
-      client.stub(:delete) { raise "Should not be called" }
-      subject.logout.should eq(nil)
-    end
-  end
-  
-  # Since the request method is overly complex, the following tests just go through the whole stack
-  # with some semi realistic requests.  Performing this type of test here should allow us to safely
-  # mock out authentication for the rest of our unit tests and still have some decent coverage.
-  describe "request" do
-    let(:client) { FlexmlsApi::Client.new({:api_key => "my_key", :api_secret => "my_secret"}) }
-    let(:session) { mock_session }
-    subject do
-      s = FlexmlsApi::Authentication::ApiAuth.new(client)
-      client.authenticator = s
-      s.session = session
-      s
-    end
-    it "should handle a get request" do
-      stub_auth_request
-      args = {
-        :ApiUser => "foobar",
-        :_limit => '10',
-        :_page => '1',
-        :_pagination => '1'
-      }
-      stub_request(:get, "#{FlexmlsApi.endpoint}/#{FlexmlsApi.version}/listings").
-        with(:query => {
-          :ApiSig => "1cb789831f8f4c6925dc708c93762a2c",
-          :AuthToken => "1234"}.merge(args)).
-        to_return(:body => fixture("listings/no_subresources.json"))
-      subject.session = session
-      subject.request(:get, "/#{FlexmlsApi.version}/listings", nil, args).status.should eq(200)
-    end
-    it "should handle a post request" do
-      stub_auth_request
-      args = {:ApiUser => "foobar"}
-      contact = '{"D":{"Contacts":[{"DisplayName":"Contact Four","PrimaryEmail":"contact4@fbsdata.com"}]}}'
-      stub_request(:post, "#{FlexmlsApi.endpoint}/#{FlexmlsApi.version}/contacts").
-        with(:query => {
-          :ApiSig => "82898ef88d22e1b31bd2e2ea6bb8efe7",
-          :AuthToken => "1234"}.merge(args),
-          :body => contact
-          ).
-        to_return(:body => '{"D": {
-          "Success": true, 
-          "Results": [
-            {
-              "ResourceUri":"/v1/contacts/20101230223226074204000000"
-            }]}
-          }', 
-          :status=>201)
-      subject.request(:post, "/#{FlexmlsApi.version}/contacts", contact, args).status.should eq(201)
-    end
-  end
-  
-  describe "sign" do
-    it "should sign the auth parameters correctly" do
-      sign_token = "my_secretApiKeymy_key"
-      subject.sign(sign_token).should eq("c731cf2455fbc7a4ef937b2301108d7a")
-    end
-  end
-  
-  describe "sign_token" do
-    let(:client) { FlexmlsApi::Client.new({:api_key => "my_key", :api_secret => "my_secret"}) }
-    subject {FlexmlsApi::Authentication::ApiAuth.new(client) }
-    it "should fully sign the token" do
-      parms = {:AuthToken => "1234", :ApiUser => "CoolAsIce"}
-      subject.sign_token("/test", parms).should eq("7bbe3384a8b64368357f8551cab271e3")
-    end
-  end
-  
-  context "when the server says the session is expired (even if we disagree)" do
-    it "should reset the session and reauthenticate" do
-      reset_config
-      count = 0
-      # Make sure the auth request goes out twice.
-      stub_request(:post, "https://api.flexmls.com/#{FlexmlsApi.version}/session").
-                  with(:query => {:ApiKey => "", :ApiSig => "806737984ab19be2fd08ba36030549ac"}).
-                  to_return do |r|
-                    count += 1
-                    {:body => fixture("session.json")}
-                  end
-      # Fail the first time, but then return the correct value after reauthentication
-      stub_request(:get, "#{FlexmlsApi.endpoint}/#{FlexmlsApi.version}/listings/1234").
-          with(:query => {
-            :ApiSig => "554b6e2a3efec8719b782647c19d238d",
-            :AuthToken => "c401736bf3d3f754f07c04e460e09573",
-            :ApiUser => "foobar",
-            :_expand => "Documents"
-          }).
-          to_return(:body => fixture('errors/expired.json'), :status => 401).times(1).then.
-          to_return(:body => fixture('listings/with_documents.json'))
-      l = Listing.find('1234', :_expand => "Documents")
-      
-      count.should eq(2)
-      FlexmlsApi.client.session.expired?.should eq(false)
-    end
-  end
-  
-end

data/spec/unit/spark_api/authentication/base_auth_spec.rb~

@@ -1,10 +0,0 @@
-require './spec/spec_helper'
-
-describe FlexmlsApi::Authentication::BaseAuth  do
-  subject {FlexmlsApi::Authentication::BaseAuth.new(nil) }
-  it "should raise an error" do
-    expect {subject.authenticate()}.to raise_error(){ |e| e.message.should == "Implement me!"}
-    expect {subject.logout()}.to raise_error(){ |e| e.message.should == "Implement me!"}
-    expect {subject.request(nil, nil, nil, nil)}.to raise_error(){ |e| e.message.should == "Implement me!"}
-  end
-end