spark_api 1.0.0

data/spec/oauth2_helper.rb

@@ -0,0 +1,68 @@
+# Lightweight example of an oauth2 provider used by the ruby client.
+class TestOAuth2Provider < SparkApi::Authentication::BaseOAuth2Provider
+  
+  def initialize
+    @authorization_uri = "https://test.fbsdata.com/r/oauth2"
+    @access_uri = "https://api.test.fbsdata.com/v1/oauth2/grant"
+    @redirect_uri = "https://exampleapp.fbsdata.com/oauth-callback"
+    @client_id="example-id"
+    @client_secret="example-password"    
+    @session_cache = {}
+  end
+  
+  def redirect(url)
+    # User redirected to url, signs in, and gets code sent to callback
+    self.code="my_code"
+  end
+  
+  def load_session()
+    @session_cache["test_user_session"]
+  end
+  
+  def save_session(session)
+    @session_cache["test_user_session"] = session
+    nil
+  end
+  
+  def session_timeout; 7200; end
+  
+end
+
+
+class TestCLIOAuth2Provider < SparkApi::Authentication::BaseOAuth2Provider
+  def initialize
+    @authorization_uri = "https://test.fbsdata.com/r/oauth2"
+    @access_uri = "https://api.test.fbsdata.com/v1/oauth2/grant"
+    @client_id="example-id"
+    @client_secret="example-secret"
+    @username="example-user"
+    @password="example-password"
+    @session_cache = {}
+  end
+  
+  def grant_type
+    :password
+  end
+  
+  def redirect(url)
+    raise "Unsupported in oauth grant_type=password mode"
+  end
+  
+  def load_session()
+    @session_cache["test_user_session"]
+  end
+  def save_session(session)
+    @session_cache["test_user_session"] = session
+    nil
+  end
+  def session_timeout; 60; end
+end
+
+
+class InvalidAuth2Provider < SparkApi::Authentication::BaseOAuth2Provider
+  
+  def grant_type
+    :not_a_real_type
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,48 @@
+require "rubygems"
+require "json"
+require "rspec"
+require 'rspec/autorun'
+require 'webmock/rspec'
+
+begin require "redgreen" unless ENV['TM_CURRENT_LINE']; rescue LoadError; end
+path = File.expand_path(File.dirname(__FILE__) + "/../lib/")
+$LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+require path + '/spark_api'
+
+require 'spark_api'
+require File.expand_path('../mock_helper', __FILE__)
+require File.expand_path('../json_helper', __FILE__)
+
+
+FileUtils.mkdir 'log' unless File.exists? 'log'
+
+# TODO, really we should change the library to support configuration without overriding
+module SparkApi
+  def self.logger
+    if @logger.nil?
+      @logger = Logger.new('log/test.log')
+      @logger.level = Logger::DEBUG
+    end
+    @logger
+  end
+end
+
+SparkApi.logger.info("Setup gem for rspec testing")
+
+def reset_config()
+  SparkApi.reset
+  SparkApi.configure do |config|
+    config.api_user = "foobar"
+  end
+end
+reset_config
+
+include SparkApi::Models
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.alias_example_to :on_get_it, :method => 'GET'
+  config.alias_example_to :on_put_it, :method => 'PUT'
+  config.alias_example_to :on_post_it, :method => 'POST'
+  config.alias_example_to :on_delete_it, :method => 'DELETE'
+end

data/spec/unit/flexmls_api_spec.rb~

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,169 @@
+require './spec/spec_helper'
+
+describe SparkApi::Authentication::ApiAuth  do
+  subject {SparkApi::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) { SparkApi::Client.new({:api_key => "my_key", :api_secret => "my_secret"}) }
+    subject do
+      s = SparkApi::Authentication::ApiAuth.new(client)
+      client.authenticator = s
+      s
+    end
+    it "should authenticate the api credentials" do
+      stub_request(:post, "https://api.sparkapi.com/#{SparkApi.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.sparkapi.com/#{SparkApi.version}/session").
+                  with(:query => {:ApiKey => "my_key", :ApiSig => "c731cf2455fbc7a4ef937b2301108d7a"}).
+                  to_return(:body => fixture("authentication_failure.json"), :status=>401)
+      expect {subject.authenticate()}.to raise_error(SparkApi::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 {SparkApi::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) { SparkApi::Client.new({:api_key => "my_key", :api_secret => "my_secret"}) }
+    let(:session) { mock_session }
+    subject do
+      s = SparkApi::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, "#{SparkApi.endpoint}/#{SparkApi.version}/listings").
+        with(:query => {
+          :ApiSig => "1cb789831f8f4c6925dc708c93762a2c",
+          :AuthToken => "1234"}.merge(args)).
+        to_return(:body => fixture("listings/no_subresources.json"))
+      subject.session = session
+      subject.request(:get, "/#{SparkApi.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, "#{SparkApi.endpoint}/#{SparkApi.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, "/#{SparkApi.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) { SparkApi::Client.new({:api_key => "my_key", :api_secret => "my_secret"}) }
+    subject {SparkApi::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.sparkapi.com/#{SparkApi.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, "#{SparkApi.endpoint}/#{SparkApi.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)
+      SparkApi.client.session.expired?.should eq(false)
+    end
+  end
+  
+end

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

@@ -0,0 +1,169 @@
+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