spark_api 1.0.2 → 1.0.4

data/spec/unit/spark_api/models/message_spec.rb~

@@ -1,47 +0,0 @@
-require './spec/spec_helper'
-
-
-describe Message do
-  before(:each) do
-    stub_auth_request
-  end
-
-  subject do
-    m = Message.new
-    m.attributes["Type"] = "ShowingRequest"
-    m.attributes["EventDateTime"] = "2011-09-15T14:00:00"
-    m.attributes["SenderId"] = "20110112234857732941000000"
-    m.attributes["Subject"] = "Showing Request For 123 Main St, MLS # 12-345"
-    m.attributes["Body"] = "A showing is requested for ..."
-    m.attributes["ListingId"] = "20110112234857732941000000"
-    m
-  end
-
-  context "/messages", :support do
-    on_get_it "should get all my messages"
-
-    on_post_it "should save a new message" do
-      stub_api_post("/messages", 'messages/new.json', 'messages/post.json')
-      subject.save.should be(true)
-    end
-
-    on_post_it "should save a new message with recipients" do
-      stub_api_post("/messages", 'messages/new_with_recipients.json', 'messages/post.json')
-      subject.attributes["Recipients"] =  ["20110112234857732941000000","20110092234857738467000000"]
-      subject.save.should be(true)
-    end
-
-    on_post_it "should fail saving" do
-      stub_api_post("/messages", 'messages/new_empty.json') do |request|
-        request.to_return(:status => 400, :body => fixture('errors/failure.json'))
-      end
-      m=subject.class.new
-      m.save.should be(false)
-      expect{ m.save! }.to raise_error(FlexmlsApi::ClientError){ |e| e.status.should == 400 }
-    end
-  end
-
-  context "/messages/<message_id>", :support do
-    on_get_it "should get a single message"
-  end
-end

data/spec/unit/spark_api/models/note_spec.rb~

@@ -1,63 +0,0 @@
-require './spec/spec_helper'
-
-describe Note do
-
-  it "responds to instance and class methods" do
-    Note.should respond_to(:get)
-    Note.new.should respond_to(:save)
-    Note.new.should respond_to(:save!)
-    Note.new.should respond_to(:delete)
-  end
-
-  context "when shared with a contact" do
-    before :each do
-      @note = Listing.new(:ListingKey => "1234").shared_notes("5678")
-      stub_auth_request
-    end
-
-    it "should have the correct path" do
-      @note.path.should == "/listings/1234/shared/notes/contacts/5678"
-    end
-
-    context "/listings/<listing_id>/shared/notes/contacts/<contact_id>", :support do
-      on_get_it "GET should get my notes" do
-        stub_api_get("#{@note.path}", 'notes/agent_shared.json')
-        ret = @note.get
-        ret.Note.should == "lorem ipsum dolor sit amet"
-      end
-
-      on_get_it "should return a nil when no shared notes exist" do
-        stub_api_get("#{@note.path}", 'notes/agent_shared_empty.json')
-        @note.get.should be_nil
-      end
-
-      on_delete_it "should allow you to delete an existing note" do
-        stub_api_delete("#{@note.path}", 'generic_delete.json')
-        @note.new.delete # test that no exceptions are raised
-      end
-
-      on_put_it "should raise an exception when adding a note fails" do
-        n = @note.new(:Note => "lorem ipsum dolor")
-
-        stub_api_put("#{@note.path}", 'notes/new.json') do |request|
-          request.to_return(:status => 500, :body => fixture('generic_failure.json'))
-        end
-
-        expect { n.save! }.to raise_error(FlexmlsApi::ClientError) { |e| e.status.should == 500 }
-        expect { n.save }.to raise_error(FlexmlsApi::ClientError) { |e| e.status.should == 500 }
-      end
-
-      on_put_it "should allow adding of a note" do
-        n = @note.new(:Note => "lorem ipsum dolor")
-        stub_api_put("#{@note.path}", 'notes/new.json', 'notes/add.json')
-        n.save
-        n.ResourceUri.should == '/v1/listings/20100909200152674436000000/shared/notes/contacts/20110407212043616271000000/'
-      end
-
-    end
-
-    after :each do
-      @note = nil
-    end
-  end
-end

data/spec/unit/spark_api/models/notification_spec.rb~

@@ -1,62 +0,0 @@
-require './spec/spec_helper'
-
-describe Notification do
-  before(:each) do
-    stub_auth_request
-  end
-
-  subject do
-    m = Notification.new
-    m.attributes['Type'] = 'OperationComplete'
-    m.attributes['Message'] = 'Your PDF generation has completed!'
-    m.attributes['BrowserUri'] = 'http://myapplication.com/cmas/19581825.pdf'
-    m.attributes['ResourceUri'] = 'http://myapplication.com/cmas/19581825.json'
-    m
-  end
-
-  context "/notifications", :support do
-    on_get_it "should get my notifications" do
-      stub_api_get('/notifications', 'notifications/notifications.json')
-
-      notifications = Notification.get
-      notifications.should be_an(Array)
-      notifications.count.should equal(3)
-    end
-
-    on_post_it "should create a new notification" do
-      stub_api_post("/notifications", 'notifications/new.json', 'notifications/post.json')
-      subject.save.should be(true)
-    end
-
-    on_post_it "should fail saving" do
-      stub_api_post("/notifications", 'notifications/new_empty.json') do |request|
-        request.to_return(:status => 400, :body => fixture('errors/failure.json'))
-      end
-      m = subject.class.new
-      m.attributes['Message'] = 'Your PDF generation has completed!'
-      m.attributes['BrowserUri'] = 'http://myapplication.com/cmas/19581825.pdf'
-      m.attributes['ResourceUri'] = 'http://myapplication.com/cmas/19581825.json'
-      m.save.should be(false)
-      expect{ m.save! }.to raise_error(FlexmlsApi::ClientError){ |e| e.status.should == 400 }
-    end
-  end
-
-  context "/notifications/<notification_id1>,<notification_id2>,...<notification_idN>", :support do
-    on_put_it "should mark notifications as read" do
-      to_mark = [12345678901234567890000001,12345678901234567890000002]
-      stub_api_put("/notifications/#{to_mark.join(',')}",
-                   'notifications/mark_read.json', 'success.json')
-
-      Notification.mark_read(to_mark)
-    end
-  end
-
-  context "/notifications/unread", :support do
-    on_get_it "should get a count of unread notifications" do
-      stub_api_get('/notifications/unread', 'notifications/unread.json', {:_pagination => 'count'})
-
-      notification_count = Notification.unread
-      notification_count.should equal(30)
-    end
-  end
-end

data/spec/unit/spark_api/models/shared_listing_spec.rb~

@@ -1,45 +0,0 @@
-require './spec/spec_helper'
-
-
-describe SharedListing do
-  before(:each) do
-    stub_auth_request
-  end
-
-  it "should respond to the finders" do
-    SharedListing.should respond_to(:find)
-  end
-
-  context "/sharedlistings", :support do
-    on_post_it "should create shared listings" do
-      stub_api_post("/#{subject.class.element_name}", 'listings/shared_listing_new.json', 'listings/shared_listing_post.json')
-      subject.ListingIds = ["20110224152431857619000000","20110125122333785431000000"]
-      subject.ViewId = "20080125122333787615000000"
-      subject.save.should be(true)
-      subject.ResourceUri.should eq("http://www.flexmls.com/share/15Ar/3544-N-Olsen-Avenue-Tucson-AZ-85719")
-    end
-
-    on_post_it "should fail creating" do
-      stub_api_post("/#{subject.class.element_name}",'empty.json') do |request|
-        request.to_return(:status => 400, :body => fixture('errors/failure.json'))
-      end
-      subject
-      subject.save.should be(false)
-      expect{ subject.save! }.to raise_error(FlexmlsApi::ClientError){ |e| e.status.should == 400 }
-    end
-  end
-
-  context "/sharedlistings/<shared_listing_id>", :support do
-    on_get_it "should get shared listing" do
-      shared_id = '15Ar'
-      stub_api_get("/#{subject.class.element_name}/#{shared_id}",
-                   'listings/shared_listing_get.json')
-
-      shared = SharedListing.find(shared_id)
-      shared.should respond_to('SharedUri')
-      shared.Mode.should eq('Public')
-      shared.ListingIds.should be_an(Array)
-    end
-  end
-
-end

data/spec/unit/spark_api/multi_client_spec.rb~

@@ -1,56 +0,0 @@
-require './spec/spec_helper'
-
-# Test client implemenations for multi client switching
-module FlexmlsApi
-  def self.test_client_a
-    Thread.current[:test_client_a] ||= Client.new(:api_key => "a")
-  end
-  def self.test_client_b
-    Client.new(:api_key => "b")
-  end
-  def self.test_client_c
-    Client.new(:api_key => "c")
-  end
-end
-
-describe FlexmlsApi::MultiClient do
-  it "should activate a client implemenation when activate()" do
-    FlexmlsApi.activate(:test_client_a)
-    FlexmlsApi.client.api_key.should eq('a')
-    FlexmlsApi.activate(:test_client_b)
-    FlexmlsApi.client.api_key.should eq('b')
-    FlexmlsApi.activate(:test_client_c)
-    FlexmlsApi.client.api_key.should eq('c')
-    FlexmlsApi.activate(:test_client_a)
-    FlexmlsApi.client.api_key.should eq('a')
-  end
-  it "should fail to activate symbols that do not have implementations" do
-    expect { FlexmlsApi.activate(:test_client_d) }.to raise_error(ArgumentError)
-  end
-  
-  it "should temporarily activate a client implemenation when activate() block" do
-    FlexmlsApi.activate(:test_client_a)
-    FlexmlsApi.client.api_key.should eq('a')
-    FlexmlsApi.activate(:test_client_b) do
-      FlexmlsApi.client.api_key.should eq('b')
-    end
-    FlexmlsApi.client.api_key.should eq('a')
-    expect do
-      FlexmlsApi.activate(:test_client_c) do
-        FlexmlsApi.client.api_key.should eq('c')
-        raise "OH MY GOODNESS I BLEW UP!!!"
-      end
-    end.to raise_error
-    FlexmlsApi.client.api_key.should eq('a')
-  end
-
-  context "yaml" do
-    it "should activate a client implemenation when activate()" do
-      FlexmlsApi::Configuration::YamlConfig.stub(:config_path) { "spec/config/flexmls_api" }
-      FlexmlsApi.activate(:test_key)
-      FlexmlsApi.client.api_key.should eq('demo_key')
-    end
-  end
-  
-end
-

data/spec/unit/spark_api/paginate_spec.rb~

@@ -1,224 +0,0 @@
-require './spec/spec_helper'
-
-class PaginateResponseTester
-  include FlexmlsApi::PaginateHelper
-end
-
-class PaginateModelTester < FlexmlsApi::Models::Base
-  @tester = PaginateResponseTester.new
-  attr_accessor :val
-  def initialize (val)
-    @val = val
-  end
-  class << self
-    attr_accessor :options
-    def get(options)
-      @options = options
-      json = "{#{paginate_json}}"
-      hash = JSON.parse(json)
-      results = @tester.paginate_response([1,2,3,4,5,6,7,8,9,10], hash["Pagination"])
-      collect(results)
-    end
-  end
-end
-
-class PaginateModelTester50 < PaginateModelTester
-  @tester = PaginateResponseTester.new
-  def self.per_page
-      50
-  end
-end
-
-
-describe FlexmlsApi::PaginateResponse do
-
-  describe "paginate_response" do
-    subject { PaginateResponseTester.new } 
-    it "should give me the first page" do
-      json = "{#{paginate_json}}"
-      hash = JSON.parse(json)
-      results = subject.paginate_response([1,2,3,4,5,6,7,8,9,10], hash["Pagination"])
-      results.offset.should eq(0)
-      results.next_page.should eq(2)
-      results.previous_page.should eq(nil)
-      results.current_page.should eq(1)
-      results.per_page.should eq(10)
-      results.total_pages.should eq(4)
-      results.total_entries.should eq(38)
-      results[0].should eq(1)
-    end
-    it "should give me the second page" do
-      json = "{#{paginate_json(2)}}"
-      hash = JSON.parse(json)
-      results = subject.paginate_response([11,12,13,14,15,16,17,18,19,20], hash["Pagination"])
-      results.offset.should eq(10)
-      results.next_page.should eq(3)
-      results.previous_page.should eq(1)
-      results.current_page.should eq(2)
-      results.per_page.should eq(10)
-      results.total_pages.should eq(4)
-      results.total_entries.should eq(38)
-      results[0].should eq(11)
-    end
-    it "should give me the third page" do
-      json = "{#{paginate_json(3)}}"
-      hash = JSON.parse(json)
-      results = subject.paginate_response([21,22,23,24,25,26,27,28,29,30], hash["Pagination"])
-      results.offset.should eq(20)
-      results.next_page.should eq(4)
-      results.previous_page.should eq(2)
-      results.current_page.should eq(3)
-      results.per_page.should eq(10)
-      results.total_pages.should eq(4)
-      results.total_entries.should eq(38)
-      results[0].should eq(21)
-    end
-    it "should give me the last page" do
-      json = "{#{paginate_json(4)}}"
-      hash = JSON.parse(json)
-      results = subject.paginate_response([31,32,33,34,35,36,37,38], hash["Pagination"])
-      results.offset.should eq(30)
-      results.next_page.should eq(nil)
-      results.previous_page.should eq(3)
-      results.current_page.should eq(4)
-      results.per_page.should eq(10)
-      results.total_pages.should eq(4)
-      results.total_entries.should eq(38)
-      results[0].should eq(31)
-      results[-1].should eq(38)
-    end
-  end
-end
-
-describe FlexmlsApi::Paginate do
-  describe "paginate" do
-    it "should give me a will paginate collection" do
-      results = PaginateModelTester.paginate(:page => 1)
-      results.should be_a(WillPaginate::Collection)
-      results.offset.should eq(0)
-      results.next_page.should eq(2)
-      results.previous_page.should eq(nil)
-      results.current_page.should eq(1)
-      results.per_page.should eq(10)
-      results.total_pages.should eq(4)
-      results.total_entries.should eq(38)
-      
-      results[0].should be_a(PaginateModelTester)
-      results[0].val.should eq(1)
-      
-    end
-      
-    it "should give me pagination options" do
-      PaginateModelTester.paginate(:page => 1)
-      opts = PaginateModelTester.options
-      opts["_pagination"].should eq(1)
-      opts["_limit"].should eq(25)
-      opts["_page"].should eq(1)
-      opts.has_key?(:page).should eq(false)
-    end
-  end
-
-  describe "per_page" do
-    it "should set the default model max results per page" do
-      results = PaginateModelTester50.paginate(:page => 1)
-      opts = PaginateModelTester50.options
-      opts["_limit"].should eq(50)
-    end
-  end
-  
-  # non unit-y real world test of paginations with listings
-  context "paginating listings" do
-    before do
-      stub_auth_request
-    end
-
-    subject { FlexmlsApi::Models::Listing }
-    it "gives me page one of listings" do
-      json = <<-JSON 
-        {"D": {
-          "Success": true, 
-          "Results": [#{ListingJson.create_all(10)}],
-          #{paginate_json}
-        }
-      JSON
-      stub_request(:get, "#{FlexmlsApi.endpoint}/#{FlexmlsApi.version}/listings").
-        with(:query => {
-          :ApiSig => "4a00ca0e657c824d85a5fe1007d9c52d",
-          :ApiUser => "foobar",
-          :AuthToken => "c401736bf3d3f754f07c04e460e09573",
-          :_limit => '10',
-          :_page => '1',
-          :_pagination => '1'
-        }).
-        to_return(:body => json)
-      results = subject.paginate(:page=>1, :per_page=>10)
-      results.should be_a(WillPaginate::Collection)
-      results.offset.should eq(0)
-      results.next_page.should eq(2)
-      results.previous_page.should eq(nil)
-      results.current_page.should eq(1)
-      results.per_page.should eq(10)
-      results.total_pages.should eq(4)
-      results.total_entries.should eq(38)
-      results.length.should eq(10)
-      
-      results[0].should be_a(subject)
-      results[0].ListPrice.should eq(50000.0)
-      
-    end
-    it "gives me page two of listings" do
-      json = <<-JSON 
-        {"D": {
-          "Success": true, 
-          "Results": [#{ListingJson.create_all(10)}],
-          #{paginate_json(2)}
-        }
-      JSON
-      stub_request(:get, "#{FlexmlsApi.endpoint}/#{FlexmlsApi.version}/listings").
-        with(:query => {
-          :ApiSig => "094d3851a0c4c4563baf70ca45087e30",
-          :ApiUser => "foobar",
-          :AuthToken => "c401736bf3d3f754f07c04e460e09573",
-          :_limit => '10',
-          :_page => '2',
-          :_pagination => '1'
-        }).
-        to_return(:body => json)
-      results = subject.paginate(:page=>2, :per_page=>10)
-      results.next_page.should eq(3)
-      results.previous_page.should eq(1)
-      results.current_page.should eq(2)
-    end
-    it "gives me page four of listings" do
-      json = <<-JSON 
-        {"D": {
-          "Success": true, 
-          "Results": [#{ListingJson.create_all(8)}],
-          #{paginate_json(4)}
-        }
-      JSON
-      stub_request(:get, "#{FlexmlsApi.endpoint}/#{FlexmlsApi.version}/listings").
-        with(:query => {
-          :ApiSig => "dcfce1fe9289c905f8d2d01cbb850edc",
-          :ApiUser => "foobar",
-          :AuthToken => "c401736bf3d3f754f07c04e460e09573",
-          :_limit => '10',
-          :_page => '4',
-          :_pagination => '1'
-        }).
-        to_return(:body => json)
-      results = subject.paginate(:page=>4, :per_page=>10)
-      results.next_page.should eq(nil)
-      results.previous_page.should eq(3)
-      results.current_page.should eq(4)
-      results.per_page.should eq(10)
-      results.total_pages.should eq(4)
-      results.total_entries.should eq(38)
-      
-      results.length.should eq(8)
-      results[0].should be_a(subject)
-      results[0].ListPrice.should eq(50000.0)
-    end
-    
-  end
-end