spark_api 1.0.2 → 1.0.4

data/spec/unit/spark_api/authentication/oauth2_impl/grant_type_base_spec.rb~

@@ -1,10 +0,0 @@
-require './spec/spec_helper'
-require './spec/oauth2_helper'
-
-describe FlexmlsApi::Authentication::OAuth2Impl::GrantTypeBase do
-  subject { FlexmlsApi::Authentication::OAuth2Impl::GrantTypeBase }
-  # Make sure the client boostraps the right plugin based on configuration.
-  it "create should " do
-    expect {subject.create(nil, InvalidAuth2Provider.new())}.to  raise_error(FlexmlsApi::ClientError){ |e| e.message.should == "Unsupported grant type [not_a_real_type]" }
-  end
-end

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

@@ -1,205 +0,0 @@
-require './spec/spec_helper'
-require './spec/oauth2_helper'
-
-describe FlexmlsApi::Authentication::OAuth2  do
-  let(:provider) { TestOAuth2Provider.new() }
-  let(:client) { FlexmlsApi::Client.new({:authentication_mode => FlexmlsApi::Authentication::OAuth2,:oauth2_provider => provider}) }
-  subject {client.authenticator }  
-  # Make sure the client boostraps the right plugin based on configuration.
-  describe "plugin" do
-    it "should load the oauth2 authenticator" do
-      client.authenticator.class.should eq(FlexmlsApi::Authentication::OAuth2)
-    end
-  end
-  describe "authenticate" do
-    it "should authenticate the api credentials" do
-      stub_request(:post, provider.access_uri).
-        with(:body => 
-            '{"code":"my_code","client_secret":"example-password","client_id":"example-id","redirect_uri":"https://exampleapp.fbsdata.com/oauth-callback","grant_type":"authorization_code"}' 
-        ).
-        to_return(:body => fixture("oauth2/access.json"), :status=>200)
-      subject.authenticate.access_token.should eq("04u7h-4cc355-70k3n")
-      subject.authenticate.expires_in.should eq(7200)
-    end
-    
-    it "should raise an error when api credentials are invalid" do
-      s=stub_request(:post, provider.access_uri).
-        with(:body => 
-             '{"code":"my_code","client_secret":"example-password","client_id":"example-id","redirect_uri":"https://exampleapp.fbsdata.com/oauth-callback","grant_type":"authorization_code"}'
-        ).
-        to_return(:body => fixture("oauth2/error.json"), :status=>400)
-      expect {subject.authenticate()}.to raise_error(FlexmlsApi::ClientError){ |e| e.status.should == 400 }
-    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_oauth_session }
-    it "should logout when there is an active session" do
-      subject.session = session
-      subject.logout
-      subject.session.should eq(nil)
-    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
-  
-  describe "request" do
-    let(:session) { mock_oauth_session }
-    it "should handle a get request" do
-      subject.session = session
-      args = {
-        :_limit => '10',
-        :_page => '1',
-        :_pagination => '1'
-      }
-      c = stub_request(:get, "https://api.flexmls.com/#{FlexmlsApi.version}/listings").
-        with(:query => 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
-      subject.session = session
-      args = {}
-      contact = '{"D":{"Contacts":[{"DisplayName":"Contact Four","PrimaryEmail":"contact4@fbsdata.com"}]}}'
-      stub_request(:post, "https://api.flexmls.com/#{FlexmlsApi.version}/contacts").
-        with(: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
-
-  context "with an expired session" do
-    context "and a valid refresh token" do
-      it "should reset the session and reauthenticate" do
-        count = 0
-        refresh_count = 0
-        stub_request(:post, provider.access_uri).
-          with(:body => '{"code":"my_code","client_secret":"example-password","client_id":"example-id","redirect_uri":"https://exampleapp.fbsdata.com/oauth-callback","grant_type":"authorization_code"}'). 
-          to_return do
-            count += 1
-            {:body => fixture("oauth2/access_with_old_refresh.json"), :status=>200}
-          end
-        stub_request(:post, provider.access_uri).
-          with(:body => '{"client_id":"example-id","client_secret":"example-password","grant_type":"refresh_token","redirect_uri":"https://exampleapp.fbsdata.com/oauth-callback","refresh_token":"0ld-r3fr35h-70k3n"}'). 
-          to_return do
-            refresh_count += 1
-            {:body => fixture("oauth2/access_with_refresh.json"), :status=>200}
-          end
-        # Make sure the auth request goes out twice.
-        # Fail the first time, but then return the correct value after reauthentication
-        stub_request(:get, "https://api.flexmls.com/#{FlexmlsApi.version}/listings/1234").
-            to_return(:body => fixture('errors/expired.json'), :status => 401).times(1).then.
-            to_return(:body => fixture('listings/with_documents.json'))
-        client.get("/listings/1234")
-        count.should eq(1)
-        refresh_count.should eq(1)
-        client.session.expired?.should eq(false)
-      end
-    end
-    context "and an invalid refresh token" do
-      it "should reset the session and reauthenticate" do
-        count = 0
-        stub_request(:post, provider.access_uri).
-          with(:body => '{"code":"my_code","client_secret":"example-password","client_id":"example-id","redirect_uri":"https://exampleapp.fbsdata.com/oauth-callback","grant_type":"authorization_code"}'). 
-          to_return do
-            count += 1
-            {:body => fixture("oauth2/access.json"), :status=>200}
-          end
-        # Make sure the auth request goes out twice.
-        # Fail the first time, but then return the correct value after reauthentication
-        stub_request(:get, "https://api.flexmls.com/#{FlexmlsApi.version}/listings/1234").
-            to_return(:body => fixture('errors/expired.json'), :status => 401).times(1).then.
-            to_return(:body => fixture('listings/with_documents.json'))
-              
-        client.get("/listings/1234")
-        count.should eq(2)
-        client.session.expired?.should eq(false)
-      end
-    end
-  end
-end
-
-describe FlexmlsApi::Authentication::BaseOAuth2Provider  do
-  context "session_timeout" do
-    it "should provide a default" do
-      subject.session_timeout.should eq(86400)
-    end
-    describe TestOAuth2Provider do
-      subject { TestOAuth2Provider.new }
-      it "should be able to override the session timeout" do
-        subject.session_timeout.should eq(7200)
-      end
-    end
-  end
-end
-
-describe "password authentication" do
-  let(:provider) { TestCLIOAuth2Provider.new() }
-  let(:client) { FlexmlsApi::Client.new({:authentication_mode => FlexmlsApi::Authentication::OAuth2,:oauth2_provider => provider}) }
-  subject {client.authenticator }  
-  it "should authenticate the api credentials with username and password" do
-    stub_request(:post, provider.access_uri).
-      with(:body => 
-        '{"username":"example-user","client_secret":"example-secret","client_id":"example-id","password":"example-password","grant_type":"password"}' 
-      ).
-      to_return(:body => fixture("oauth2/access.json"), :status=>200)
-    subject.authenticate.access_token.should eq("04u7h-4cc355-70k3n")
-    subject.authenticate.expires_in.should eq(60)
-  end
-end
-describe FlexmlsApi::Authentication::OAuth2Impl  do
-  it "should load a provider" do
-    example = "FlexmlsApi::Authentication::OAuth2Impl::PasswordProvider"
-    FlexmlsApi::Authentication::OAuth2Impl.load_provider(example,{}).class.to_s.should eq(example)
-    prefix = "::#{example}"
-    FlexmlsApi::Authentication::OAuth2Impl.load_provider(prefix,{}).class.to_s.should eq(example)
-    bad_example = "Derp::Derp::Derp::DerpProvider"
-    expect{FlexmlsApi::Authentication::OAuth2Impl.load_provider(bad_example,{}).class.to_s.should eq(bad_example)}.to raise_error(ArgumentError)
-  end
-
-end
-
-describe FlexmlsApi::Authentication::OAuthSession do
-  it "should serialize to json" do
-    args = {
-      "access_token" => "abc", 
-      "expires_in" => 3600, 
-      "refresh_token" => "123", 
-      "refresh_timeout" => 10000,
-      "start_time" => "2012-01-01T00:00:00+00:00"
-    }
-    session = FlexmlsApi::Authentication::OAuthSession.new(args)
-    session.start_time.should eq(DateTime.parse(args["start_time"]))
-    JSON.parse(session.to_json).should eq(args)
-    
-  end
-end

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

@@ -1,38 +0,0 @@
-require './spec/spec_helper'
-
-describe FlexmlsApi::Authentication do
-  before(:all) do
-    FlexmlsApi.reset
-  end
-  
-  after(:all) do
-    reset_config
-  end
-
-  it "should give me a session object" do
-    stub_auth_request
-    stub_request(:get, "#{FlexmlsApi.endpoint}/#{FlexmlsApi.version}/session/c401736bf3d3f754f07c04e460e09573").
-      with(:query => {
-        :ApiSig => "5596eff4550d74ec6802ac2d637ae5ae",
-        :AuthToken => "c401736bf3d3f754f07c04e460e09573"
-      }).
-      to_return(:body => fixture("session.json"))
-    client = FlexmlsApi.client
-    stub_auth_request
-    session = client.get "/session/c401736bf3d3f754f07c04e460e09573"
-    session[0]["AuthToken"].should eq("c401736bf3d3f754f07c04e460e09573")
-  end
-  it "should delete a session" do
-    stub_auth_request
-    stub_request(:delete, "#{FlexmlsApi.endpoint}/#{FlexmlsApi.version}/session/c401736bf3d3f754f07c04e460e09573").
-      with(:query => {
-        :ApiSig => "5596eff4550d74ec6802ac2d637ae5ae",
-        :AuthToken => "c401736bf3d3f754f07c04e460e09573"
-      }).
-      to_return(:body => fixture("success.json"))
-    client = FlexmlsApi.client
-    client.logout
-    client.session.should eq(nil)
-  end
-
-end

data/spec/unit/spark_api/configuration/yaml_spec.rb~

@@ -1,72 +0,0 @@
-require './spec/spec_helper'
-
-describe FlexmlsApi::Configuration::YamlConfig, "Yaml Config"  do
-  describe "api auth" do
-    let(:api_file){ "spec/config/flexmls_api/test_key.yml" }
-    it "should load a configured api key for development" do
-      subject.stub(:env){ {} }
-      subject.api_env.should eq("development")
-      subject.load_file(api_file)
-      subject.oauth2?.should eq(false)
-      subject.api_key.should eq("demo_key")
-      subject.api_secret.should eq("t3sts3cr3t")
-      subject.endpoint.should eq("http://api.dev.flexmls.com")
-      subject.name.should eq("test_key")
-      subject.client_keys.keys.should =~ [:api_key, :api_secret, :endpoint]
-      subject.oauth2_keys.keys.should eq([])
-    end
-    it "should load a configured api key for production" do
-      subject.stub(:env){ {"FLEXMLS_API_ENV" => "production"} }
-      subject.api_env.should eq("production")
-      subject.load_file(api_file)
-      subject.oauth2?.should eq(false)
-      subject.api_key.should eq("prod_demo_key")
-      subject.api_secret.should eq("prod_t3sts3cr3t")
-      subject.endpoint.should eq("http://api.test.flexmls.com")
-    end
-    it "should raise an error for a bad configuration" do
-      subject.stub(:env){ {} }
-      expect { subject.load_file("spec/config/flexmls_api/some_random_key.yml")}.to raise_error
-      subject.stub(:env){ {"RAILS_ENV" => "fake_env"} }
-      expect { subject.load_file(api_file)}.to raise_error
-    end
-  end
-  describe "oauth2" do
-    let(:oauth2_file){ "spec/config/flexmls_api/test_oauth.yml" }
-    it "should load a configured api key for development" do
-      subject.stub(:env){ {} }
-      subject.api_env.should eq("development")
-      subject.load_file(oauth2_file)
-      subject.oauth2?.should eq(true)
-      subject.authorization_uri.should eq("https://dev.flexmls.com/r/login/")
-      subject.access_uri.should eq("https://api.dev.flexmls.com/v1/oauth2/grant")
-      subject.redirect_uri.should eq("http://localhost/oauth2/callback")
-      subject.client_id.should eq("developmentid124nj4qu3pua")
-      subject.client_secret.should eq("developmentsecret4orkp29f")
-      subject.endpoint.should eq("http://api.dev.flexmls.com")
-      subject.oauth2_provider.should eq("FlexmlsApi::TestOAuth2Provider")
-      subject.name.should eq("test_oauth")
-      subject.client_keys.keys.should =~ [:endpoint, :oauth2_provider]
-      subject.oauth2_keys.keys.should =~ [:authorization_uri, :client_id, :access_uri, :client_secret, :redirect_uri]
-    end
-    it "should load a configured api key for production" do
-      subject.stub(:env){ {"FLEXMLS_API_ENV" => "production"} }
-      subject.api_env.should eq("production")
-      subject.load_file(oauth2_file)
-      subject.oauth2?.should eq(true)
-      subject.authorization_uri.should eq("https://www.flexmls.com/r/login/")
-      subject.access_uri.should eq("https://api.flexmls.com/v1/oauth2/grant")
-      subject.redirect_uri.should eq("http://localhost/oauth2/callback")
-      subject.client_id.should eq("production1id124nj4qu3pua")
-      subject.client_secret.should eq("productionsecret4orkp29fv")
-      subject.endpoint.should eq("http://api.flexmls.com")
-      subject.oauth2_provider.should eq(subject.class::DEFAULT_OAUTH2_PROVIDER)
-      subject.name.should eq("test_oauth")
-    end
-    
-    it "should list available keys" do
-      FlexmlsApi::Configuration::YamlConfig.stub(:config_path) { "spec/config/flexmls_api" }
-      subject.class.config_keys.should =~ ["test_key", "test_oauth"]
-    end
-  end
-end

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

@@ -1,122 +0,0 @@
-require './spec/spec_helper'
-
-describe FlexmlsApi::Client, "Client config"  do
-  after(:all) do
-    reset_config
-  end
-
-  describe "default settings" do
-    it "should return the proper defaults when called with no arguments" do
-      FlexmlsApi.api_key.should be_nil
-      FlexmlsApi.api_secret.should be_nil
-      FlexmlsApi.version.should match("v1")
-      FlexmlsApi.endpoint.should match("api.flexmls.com")
-      FlexmlsApi.user_agent.should match(/flexmls API Ruby Gem .*/)
-      FlexmlsApi.api_key = "my_api_key"
-      FlexmlsApi.api_key.should match("my_api_key")
-    end
-  end
-
-  describe "instance config" do
-    it "should return a properly configured client" do
-      client = FlexmlsApi::Client.new(:api_key => "key_of_wade", 
-                                      :api_secret => "TopSecret", 
-                                      :api_user => "1234",
-                                      :endpoint => "http://api.wade.dev.fbsdata.com")
- 
-      client.api_key.should match("key_of_wade")
-      client.api_secret.should match("TopSecret")
-      client.api_user.should match("1234")
-      client.endpoint.should match("http://api.wade.dev.fbsdata.com")
-      client.version.should match("v1")
-    end
-  end
-
-  describe "block config" do
-    it "should correctly set up the client" do
-      FlexmlsApi.configure do |config|
-        config.api_key = "my_key"
-        config.api_secret = "my_secret"
-        config.api_user = "1234"
-        config.version = "veleventy"
-        config.endpoint = "test.api.flexmls.com"
-        config.user_agent = "my useragent"
-      end
-
-      FlexmlsApi.api_key.should match("my_key")
-      FlexmlsApi.api_secret.should match("my_secret")
-      FlexmlsApi.api_user.should match("1234")
-      FlexmlsApi.version.should match("veleventy")
-      FlexmlsApi.endpoint.should match("test.api.flexmls.com")
-      FlexmlsApi.user_agent.should match("my useragent")
-
-    end
-    
-    it "should reset" do
-      FlexmlsApi.configure do |config|
-        config.api_key = "my_key"
-        config.api_secret = "my_secret"
-        config.version = "veleventy"
-        config.endpoint = "test.api.flexmls.com"
-        config.user_agent = "my useragent"
-      end
-      
-      FlexmlsApi.api_key.should match("my_key")
-      FlexmlsApi.reset
-      FlexmlsApi.api_key.should == FlexmlsApi::Configuration::DEFAULT_API_KEY
-    
-    end
-  end
-
-  describe "connections" do
-    it "should use http by default" do
-      stub_auth_request
-      stub_request(:get, "#{FlexmlsApi.endpoint}/#{FlexmlsApi.version}/connections").
-          with(:query => {
-            :ApiSig => "951e5ba0496b0758356d3cc7676f8b21",
-            :AuthToken => "c401736bf3d3f754f07c04e460e09573"
-          }).
-          to_return(:body => '{"D":{"Success": true,"Results": [{"SSL":false}]}}')
-          
-      FlexmlsApi.client.get('/connections')[0]["SSL"].should eq(false)
-    end
-
-    it "should use https when ssl is enabled" do
-      stub_auth_request
-      stub_request(:get, "https://api.flexmls.com/#{FlexmlsApi.version}/connections").
-          with(:query => {
-            :ApiSig => "951e5ba0496b0758356d3cc7676f8b21",
-            :AuthToken => "c401736bf3d3f754f07c04e460e09573"
-          }).
-          to_return(:body => '{"D":{"Success": true,"Results": [{"SSL":true}]}}')
-          
-      c = FlexmlsApi::Client.new(:endpoint => "https://api.flexmls.com", :ssl => true)
-      c.get('/connections')[0]["SSL"].should eq(true)
-    end
-    
-    it "should have correct headers based on configuration" do
-      stub_auth_request
-      stub_request(:get, "#{FlexmlsApi.endpoint}/#{FlexmlsApi.version}/headers").
-          with(:query => {
-            :ApiSig => "6f0cfef263e0bfe7a9ae1f60063a8ad9",
-            :AuthToken => "c401736bf3d3f754f07c04e460e09573"
-          }).
-          to_return(:body => '{"D":{"Success": true,"Results": []}}')
-      FlexmlsApi.reset
-      FlexmlsApi.configure do |config|
-        config.user_agent = "my useragent"
-      end
-      FlexmlsApi.client.get '/headers'
-      WebMock.should have_requested(:get, "#{FlexmlsApi.endpoint}/#{FlexmlsApi.version}/headers?ApiSig=6f0cfef263e0bfe7a9ae1f60063a8ad9&AuthToken=c401736bf3d3f754f07c04e460e09573").
-        with(:headers => {
-          'User-Agent' => FlexmlsApi::Configuration::DEFAULT_USER_AGENT,
-          FlexmlsApi::Configuration::X_FLEXMLS_API_USER_AGENT => "my useragent",
-          'Accept'=>'application/json', 
-          'Content-Type'=>'application/json'
-        })
-    end
-    
-  end
-
-end
-