yammer-client 0.1.2 → 0.1.3

data/lib/yammer/http_connection.rb

@@ -1,184 +0,0 @@
-begin
-  require 'net/https'
-rescue LoadError
-  warn "Warning: no such file to load -- net/https. Make sure openssl is installed if you want ssl support"
-  require 'net/http'
-end
-require 'zlib'
-require 'addressable/uri'
-
-module Yammer
-  class HttpConnection
-
-    class UnhandledHTTPMethodError < StandardError; end
-    class UnsupportedSchemeError < StandardError; end
-
-    NET_HTTP_EXCEPTIONS = [
-      EOFError,
-      Errno::ECONNABORTED,
-      Errno::ECONNREFUSED,
-      Errno::ECONNRESET,
-      Errno::EINVAL,
-      Net::HTTPBadResponse,
-      Net::HTTPHeaderSyntaxError,
-      Net::ProtocolError,
-      SocketError,
-      Zlib::GzipFile::Error,
-    ] unless defined? NET_HTTP_EXCEPTIONS
-
-    attr_accessor :config, :scheme, :host, :port, :max_redirects, :ssl,
-                  :user_agent, :accept, :max_redirects, :headers, :uri
-
-    def self.default_options
-      {
-        :headers => {
-          'Accept'     => 'application/json',
-          'User-Agent' => "Yammer Ruby Gem #{Yammer::Version}"
-        },
-        :ssl => {:verify => true},
-        :max_redirects => 5
-      }
-    end
-
-    def initialize(url, options={})
-      @uri = Addressable::URI.parse(url)
-      self.class.default_options.keys.each do |key|
-        instance_variable_set(:"@#{key}", options.fetch(key, self.class.default_options[key]))
-      end
-    end
-
-    def default_headers
-      self.class.default_options[:headers]
-    end
-
-    def scheme=(scheme)
-      unless ['http', 'https'].include? scheme
-        raise UnsupportedSchemeError.new "#{scheme} is not supported, only http and https"
-      end
-      @scheme = scheme
-    end
-
-    def scheme
-      @scheme ||= @uri.scheme
-    end
-
-    def host
-      @host ||= @uri.host
-    end
-
-    def port
-      _port = ssl? ? 443 : 80
-      @port = @uri.port || _port
-    end
-
-    def absolute_url(path='')
-      "#{scheme}://#{host}#{path}"
-    end
-
-    def ssl?
-      scheme == "https" ? true : false
-    end
-
-    def ssl=(opts)
-      raise "Expected Hash but got #{opts.class.name}" unless opts.is_a?(Hash)
-      @ssl.merge!(opts)
-    end
-
-    def http_connection(opts={})
-      _host   = opts[:host]   || host
-      _port   = opts[:port]   || port
-      _scheme = opts[:scheme] || scheme
-
-      @http_client = Net::HTTP.new(_host, _port)
-
-      configure_ssl(@http_client) if _scheme == 'https'
-
-      @http_client
-    end
-
-    def send_request(method, path, opts={})
-      headers         = @headers.merge(opts.fetch(:headers, {}))
-      params          = opts[:params] || {}
-      query           = Addressable::URI.form_encode(params)
-      method          = method.to_sym
-      normalized_path = query.empty? ? path : [path, query].join("?")
-      client          = http_connection(opts.fetch(:connection_options, {}))
-
-      if (method == :post || method == :put)
-        headers['Content-Type'] ||= 'application/x-www-form-urlencoded'
-      end
-
-      case method
-      when :get, :delete
-        response = client.send(method, normalized_path, headers)
-      when :post, :put
-        response = client.send(method, path, query, headers)
-      else
-        raise UnhandledHTTPMethodError.new("Unsupported HTTP method, #{method}")
-      end
-
-      status = response.code.to_i
-
-      case status
-      when 301, 302, 303, 307
-        unless redirect_limit_reached?
-          if status == 303
-            method = :get
-            params = nil
-            headers.delete('Content-Type')
-          end
-          redirect_uri = Addressable::URI.parse(response.header['Location'])
-          conn = {
-            :scheme => redirect_uri.scheme,
-            :host   => redirect_uri.host,
-            :port   => redirect_uri.port
-          }
-          return send_request(method, redirect_uri.path, :params => params, :headers => headers, :connection_options => conn)
-        end
-      when 100..599
-        @redirect_count = 0
-      else
-        raise "Unhandled status code value of #{response.code}"
-      end
-      response
-    rescue *NET_HTTP_EXCEPTIONS
-      raise "Error::ConnectionFailed, #{$!.backtrace}"
-    end
-
-  private
-
-    def configure_ssl(http)
-      http.use_ssl      = true
-      http.verify_mode  = ssl_verify_mode
-      http.cert_store   = ssl_cert_store
-
-      http.cert         = ssl[:client_cert]  if ssl[:client_cert]
-      http.key          = ssl[:client_key]   if ssl[:client_key]
-      http.ca_file      = ssl[:ca_file]      if ssl[:ca_file]
-      http.ca_path      = ssl[:ca_path]      if ssl[:ca_path]
-      http.verify_depth = ssl[:verify_depth] if ssl[:verify_depth]
-      http.ssl_version  = ssl[:version]      if ssl[:version]
-    end
-
-    def ssl_verify_mode
-      if ssl.fetch(:verify, true)
-          OpenSSL::SSL::VERIFY_PEER
-      else
-          OpenSSL::SSL::VERIFY_NONE
-      end
-    end
-
-    def ssl_cert_store
-      return ssl[:cert_store] if ssl[:cert_store]
-      cert_store = OpenSSL::X509::Store.new
-      cert_store.set_default_paths
-      cert_store
-    end
-
-    def redirect_limit_reached?
-      @redirect_count ||= 0
-      @redirect_count += 1
-      @redirect_count > @max_redirects
-    end
-  end
-end

data/lib/yammer/model.rb

@@ -1,6 +0,0 @@
-require 'yammer/base'
-require 'yammer/user'
-require 'yammer/group'
-require 'yammer/group_membership'
-require 'yammer/message'
-require 'yammer/thread'

data/spec/connection_spec.rb

@@ -1,306 +0,0 @@
-require File.expand_path('../spec_helper', __FILE__)
-require 'yammer/http_connection'
-
-describe Yammer::HttpConnection do
-
-  before :all do
-    Yammer.configure do |conf|
-      conf.access_token = 'TolNOFka9Uls2DxahNi78A'
-    end
-  end
-
-  subject do
-    @conn = Yammer::HttpConnection.new('https://yammer.com')
-  end
-
-  context "with user options" do
-    before do
-      @options = {
-        :headers => {
-          'Accept'     => 'application/json',
-          'User-Agent' => "Yammer Ruby Gem #{Yammer::Version}"
-        },
-        :ssl => {:verify => false},
-        :max_redirects => 2
-      }
-      @conn = Yammer::HttpConnection.new('https://microsoft.com', @options)
-    end
-
-    it "overrides default options" do
-      opts = Yammer::HttpConnection.default_options
-      opts.keys.each do |key|
-        expect(@conn.instance_variable_get(:"@#{key}")).to eq @options[key]
-      end
-    end
-  end
-
-  describe "#default_headers" do
-    it "returns user_agent and response format" do
-      expect(subject.default_headers).to eq ({
-        "Accept"     => "application/json",
-        "User-Agent" => "Yammer Ruby Gem #{Yammer::Version}"
-      })
-    end
-  end
-
-  describe "#scheme" do
-    it "returns the http scheme" do
-      expect(subject.scheme).to eq 'https'
-    end
-  end
-
-  describe "#scheme" do
-    context "scheme is unsupported" do
-      it "raises an error" do
-        expect { subject.scheme = 'ftp'}.to raise_error(Yammer::HttpConnection::UnsupportedSchemeError)
-      end
-    end
-
-    context "scheme is http" do
-      it "sets the scheme" do
-        subject.scheme = 'http'
-        expect(subject.scheme).to eq 'http'
-      end
-    end
-
-    context "scheme is https" do
-      it "sets the scheme" do
-        subject.scheme = 'https'
-        expect(subject.scheme).to eq 'https'
-      end
-    end
-  end
-
-  describe "#host" do
-    it "returns the host server" do
-      expect(subject.host).to eq 'yammer.com'
-    end
-  end
-
-  describe "#port" do
-    it "returns the port" do
-      expect(subject.port).to eq 443
-    end
-  end
-
-  describe "#ssl?" do
-    context "scheme is https" do
-      it "returns true" do
-        subject.scheme = 'https'
-        expect(subject.ssl?).to eq true
-      end
-    end
-
-    context "scheme is http" do
-      it "returns false" do
-        subject.scheme = 'http'
-        expect(subject.ssl?).to eq false
-      end
-    end
-  end
-
-  describe "#http_connection" do
-    it "behaves like HTTP client" do
-      expect(subject.http_connection).to respond_to(:get)
-      expect(subject.http_connection).to respond_to(:post)
-      expect(subject.http_connection).to respond_to(:put)
-      expect(subject.http_connection).to respond_to(:delete)
-    end
-  end
-
-  describe "#absolute_url" do
-    context "with no parameters" do
-      it "returns a uri without path" do
-        expect(subject.absolute_url).to eq "https://yammer.com"
-      end
-    end
-
-    context "with parameters" do
-      it "returns a uri with path" do
-        expect(subject.absolute_url('/oauth/v2/authorize')).to eq "https://yammer.com/oauth/v2/authorize"
-      end
-    end
-  end
-
-  describe "#configure_ssl" do
-  end
-
-  describe "#redirect_limit_reached?" do
-  end
-
-  describe "#ssl_verify_mode" do
-    context "ssl verify set to true" do
-      it "returns OpenSSL::SSL::VERIFY_PEER" do
-        subject.ssl = { :verify => true }
-        expect(subject.send(:ssl_verify_mode)).to eq OpenSSL::SSL::VERIFY_PEER
-      end
-    end
-
-    context "ssl verify set to false" do
-      it "returns OpenSSL::SSL::VERIFY_NONE" do
-        subject.ssl = { :verify => false }
-        expect(subject.send(:ssl_verify_mode)).to eq OpenSSL::SSL::VERIFY_NONE
-      end
-    end
-  end
-
-  describe "ssl_cert_store" do
-  end
-
-  describe "#send_request" do
-    before do
-      @http_ok = OpenStruct.new(
-        :code    => '200',
-        :body    => 'success',
-        :header => {'Content-Type' => "application/json"}
-      )
-      @http_redirect = OpenStruct.new(
-        :code    => '301',
-        :body    => 'redirect',
-        :header => {'Location' => "http://yammer.com/members"}
-      )
-    end
-
-    context "when method is not supported" do
-      it "raises an error" do
-        expect {subject.send_request(:patch, '/')}.to raise_error(Yammer::HttpConnection::UnhandledHTTPMethodError)
-      end
-    end
-
-    context "when method is get" do
-      it "returns an http response" do
-        path = '/oauth/authorize'
-        params = {:client_id => '001337', :client_secret => 'abcxyz'}
-        method = :get
-
-        normalized_path = '/oauth/authorize?client_id=001337&client_secret=abcxyz'
-
-        stub_request(:get, "https://yammer.com/oauth/authorize?client_id=001337&client_secret=abcxyz").with(
-          :headers => {
-            'Accept'=>'application/json',
-            'User-Agent'=>"Yammer Ruby Gem #{Yammer::Version}"
-        })
-        response = subject.send_request(method, path, :params => params)
-
-        expect(response.code).to eq '200'
-      end
-    end
-
-    context "when method is delete" do
-      it "returns an http response" do
-        path = '/users/1'
-        method = 'delete'
-
-        stub_request(:delete, "https://yammer.com/users/1").with(
-          :headers => {
-            'Accept'=>'application/json',
-            'User-Agent'=>"Yammer Ruby Gem #{Yammer::Version}"
-          }).to_return(:status => 200, :body => "", :headers => {})
-
-        response = subject.send_request(method, path)
-        expect(response.code).to eq '200'
-      end
-    end
-
-    context "when method is post" do
-      it "returns an http response" do
-        path = '/users'
-        params = {:first_name => 'john', :last_name => 'smith'}
-        query  = Addressable::URI.form_encode(params)
-        headers = {'Content-Type' => 'application/x-www-form-urlencoded' }.merge(subject.default_headers)
-
-        stub_request(:post, "https://yammer.com/users").with(
-          :body => {
-            "first_name"=>"john",
-            "last_name"=>"smith"
-            },
-          :headers => {
-            'Accept'=>'application/json',
-            'Content-Type'=>'application/x-www-form-urlencoded',
-            'User-Agent'=>"Yammer Ruby Gem #{Yammer::Version}"
-        }).to_return(:status => 200, :body => "", :headers => {})
-
-        response =subject.send_request(:post, path, :params => params)
-        expect(response.code).to eq '200'
-      end
-    end
-
-    context "when method is put" do
-      it "returns an http response" do
-        path = '/users/1'
-        params = {:first_name => 'jane', :last_name => 'doe'}
-        query  = Addressable::URI.form_encode(params)
-        headers = {'Content-Type' => 'application/x-www-form-urlencoded' }.merge(subject.default_headers)
-
-        stub_request(:put, "https://yammer.com/users/1").with(
-          :body => {
-            "first_name" => "jane",
-            "last_name"  => "doe"
-          },
-          :headers => {
-            'Accept'=>'application/json',
-            'Content-Type'=>'application/x-www-form-urlencoded',
-            'User-Agent'=>"Yammer Ruby Gem #{Yammer::Version}"
-          }).
-         to_return(:status => 200, :body => "", :headers => {})
-
-        response = subject.send_request(:put, path, :params => params)
-        expect(response.code).to eq '200'
-      end
-    end
-
-    it "follows redirect" do
-      path = '/users'
-      params = {:first_name => 'jane', :last_name => 'doe'}
-      query  = Addressable::URI.form_encode(params)
-      headers = {'Content-Type' => 'application/x-www-form-urlencoded' }.merge(subject.default_headers)
-      client = double("client")
-
-      subject.should_receive(:http_connection).twice.and_return(client, client)
-      client.should_receive(:post).ordered.with(path, query, headers).and_return(@http_redirect)
-      client.should_receive(:post).ordered.with('/members', query, headers).and_return(@http_ok)
-
-      response = subject.send_request(:post, path, :params => params)
-
-      expect(response.code).to eq '200'
-    end
-
-    it "respects the redirect limit " do
-      subject.max_redirects = 1
-      path = '/users'
-      params = {:first_name => 'jane', :last_name => 'doe'}
-      query  = Addressable::URI.form_encode(params)
-      headers = {'Content-Type' => 'application/x-www-form-urlencoded' }.merge(subject.default_headers)
-      client = double("client")
-
-      subject.should_receive(:http_connection).twice.and_return(client, client)
-      client.should_receive(:post).ordered.with(path, query, headers).and_return(@http_redirect)
-      client.should_receive(:post).ordered.with('/members', query, headers).and_return(@http_redirect)
-
-      response = subject.send_request(:post, path, :params => params)
-
-      expect(response.code).to eq '301'
-    end
-
-    it "modifies http 303 redirect from POST to GET " do
-      http_303 = OpenStruct.new(
-        :code    => '303',
-        :body    => 'redirect',
-        :header => {'Location' => "http://yammer.com/members"}
-      )
-      path = '/users'
-      params = {:first_name => 'jane', :last_name => 'doe'}
-      query  = Addressable::URI.form_encode(params)
-      headers = {'Content-Type' => 'application/x-www-form-urlencoded' }.merge(subject.default_headers)
-      client = double("client")
-
-      subject.should_receive(:http_connection).twice.and_return(client, client)
-      client.should_receive(:post).ordered.with(path, query, headers).and_return(http_303)
-      client.should_receive(:get).ordered.with('/members', subject.default_headers).and_return(@http_ok)
-
-      response = subject.send_request(:post, path, :params => params)
-
-      expect(response.code).to eq '200'
-    end
-  end
-end