plyom_user 0.0.1 → 0.0.2

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/spec/httparty/connection_adapter_spec.rb

@@ -0,0 +1,223 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe HTTParty::ConnectionAdapter do
+
+  describe "initialization" do
+    let(:uri) { URI 'http://www.google.com' }
+    it "takes a URI as input" do
+      HTTParty::ConnectionAdapter.new(uri)
+    end
+
+    it "raises an ArgumentError if the uri is nil" do
+      expect { HTTParty::ConnectionAdapter.new(nil) }.to raise_error ArgumentError
+    end
+
+    it "raises an ArgumentError if the uri is a String" do
+      expect { HTTParty::ConnectionAdapter.new('http://www.google.com') }.to raise_error ArgumentError
+    end
+
+    it "sets the uri" do
+      adapter = HTTParty::ConnectionAdapter.new(uri)
+      adapter.uri.should be uri
+    end
+
+    it "also accepts an optional options hash" do
+      HTTParty::ConnectionAdapter.new(uri, {})
+    end
+
+    it "sets the options" do
+      options = {:foo => :bar}
+      adapter = HTTParty::ConnectionAdapter.new(uri, options)
+      adapter.options.should be options
+    end
+  end
+
+  describe ".call" do
+    it "generates an HTTParty::ConnectionAdapter instance with the given uri and options" do
+      HTTParty::ConnectionAdapter.should_receive(:new).with(@uri, @options).and_return(stub(:connection => nil))
+      HTTParty::ConnectionAdapter.call(@uri, @options)
+    end
+
+    it "calls #connection on the connection adapter" do
+      adapter = mock('Adapter')
+      connection = mock('Connection')
+      adapter.should_receive(:connection).and_return(connection)
+      HTTParty::ConnectionAdapter.stub(:new => adapter)
+      HTTParty::ConnectionAdapter.call(@uri, @options).should be connection
+    end
+  end
+
+  describe '#connection' do
+    let(:uri) { URI 'http://www.google.com' }
+    let(:options) { Hash.new }
+    let(:adapter) { HTTParty::ConnectionAdapter.new(uri, options) }
+
+    describe "the resulting connection" do
+      subject { adapter.connection }
+      it { should be_an_instance_of Net::HTTP }
+
+      context "using port 80" do
+        let(:uri) { URI 'http://foobar.com' }
+        it { should_not use_ssl }
+      end
+
+      context "when dealing with ssl" do
+        let(:uri) { URI 'https://foobar.com' }
+
+        context "using port 443 for ssl" do
+          let(:uri) { URI 'https://api.foo.com/v1:443' }
+          it { should use_ssl }
+        end
+
+        context "https scheme with default port" do
+          it { should use_ssl }
+        end
+
+        context "https scheme with non-standard port" do
+          let(:uri) { URI 'https://foobar.com:123456' }
+          it { should use_ssl }
+        end
+
+
+        context "when ssl version is set" do
+          let(:options) { {:ssl_version => :TLSv1} }
+
+          it "sets ssl version" do
+            subject.ssl_version.should == :TLSv1
+          end
+        end if RUBY_VERSION > '1.9'
+      end
+
+      context "when dealing with IPv6" do
+        let(:uri) { URI 'http://[fd00::1]' }
+
+        it "strips brackets from the address" do
+          subject.address.should == 'fd00::1'
+        end
+      end
+
+      context "specifying ciphers" do
+        let(:options) { {:ciphers => 'RC4-SHA' } }
+
+        it "should set the ciphers on the connection" do
+          subject.ciphers.should == 'RC4-SHA'
+        end
+      end if RUBY_VERSION > '1.9'
+
+      context "when timeout is not set" do
+        it "doesn't set the timeout" do
+          http = mock("http", :null_object => true)
+          http.should_not_receive(:open_timeout=)
+          http.should_not_receive(:read_timeout=)
+          Net::HTTP.stub(:new => http)
+
+          adapter.connection
+        end
+      end
+
+      context "when setting timeout" do
+        context "to 5 seconds" do
+          let(:options) { {:timeout => 5} }
+
+          its(:open_timeout) { should == 5 }
+          its(:read_timeout) { should == 5 }
+        end
+
+        context "and timeout is a string" do
+          let(:options) { {:timeout => "five seconds"} }
+
+          it "doesn't set the timeout" do
+            http = mock("http", :null_object => true)
+            http.should_not_receive(:open_timeout=)
+            http.should_not_receive(:read_timeout=)
+            Net::HTTP.stub(:new => http)
+
+            adapter.connection
+          end
+        end
+      end
+
+      context "when debug_output" do
+        let(:http) { Net::HTTP.new(uri) }
+        before do
+          Net::HTTP.stub(:new => http)
+        end
+
+        context "is set to $stderr" do
+          let(:options) { {:debug_output => $stderr} }
+          it "has debug output set" do
+            http.should_receive(:set_debug_output).with($stderr)
+            adapter.connection
+          end
+        end
+
+        context "is not provided" do
+          it "does not set_debug_output" do
+            http.should_not_receive(:set_debug_output)
+            adapter.connection
+          end
+        end
+      end
+
+      context 'when providing proxy address and port' do
+        let(:options) { {:http_proxyaddr => '1.2.3.4', :http_proxyport => 8080} }
+
+        it { should be_a_proxy }
+        its(:proxy_address) { should == '1.2.3.4' }
+        its(:proxy_port) { should == 8080 }
+
+        context 'as well as proxy user and password' do
+          let(:options) do
+            {:http_proxyaddr => '1.2.3.4', :http_proxyport => 8080,
+             :http_proxyuser => 'user', :http_proxypass => 'pass'}
+          end
+          its(:proxy_user) { should == 'user' }
+          its(:proxy_pass) { should == 'pass' }
+        end
+      end
+
+      context "when providing PEM certificates" do
+        let(:pem) { :pem_contents }
+        let(:options) { {:pem => pem, :pem_password => "password"} }
+
+        context "when scheme is https" do
+          let(:uri) { URI 'https://google.com' }
+          let(:cert) { mock("OpenSSL::X509::Certificate") }
+          let(:key) { mock("OpenSSL::PKey::RSA") }
+
+          before do
+            OpenSSL::X509::Certificate.should_receive(:new).with(pem).and_return(cert)
+            OpenSSL::PKey::RSA.should_receive(:new).with(pem, "password").and_return(key)
+          end
+
+          it "uses the provided PEM certificate " do
+            subject.cert.should == cert
+            subject.key.should == key
+          end
+
+          it "will verify the certificate" do
+            subject.verify_mode.should == OpenSSL::SSL::VERIFY_PEER
+          end
+        end
+
+        context "when scheme is not https" do
+          let(:uri) { URI 'http://google.com' }
+          let(:http) { Net::HTTP.new(uri) }
+
+          before do
+            Net::HTTP.stub(:new => http)
+            OpenSSL::X509::Certificate.should_not_receive(:new).with(pem)
+            OpenSSL::PKey::RSA.should_not_receive(:new).with(pem, "password")
+            http.should_not_receive(:cert=)
+            http.should_not_receive(:key=)
+          end
+
+          it "has no PEM certificate " do
+            subject.cert.should be_nil
+            subject.key.should be_nil
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/spec/httparty/cookie_hash_spec.rb

@@ -0,0 +1,76 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe HTTParty::CookieHash do
+  before(:each) do
+    @cookie_hash = HTTParty::CookieHash.new
+  end
+
+  describe "#add_cookies" do
+    describe "with a hash" do
+      it "should add new key/value pairs to the hash" do
+        @cookie_hash.add_cookies(:foo => "bar")
+        @cookie_hash.add_cookies(:rofl => "copter")
+        @cookie_hash.length.should eql(2)
+      end
+
+      it "should overwrite any existing key" do
+        @cookie_hash.add_cookies(:foo => "bar")
+        @cookie_hash.add_cookies(:foo => "copter")
+        @cookie_hash.length.should eql(1)
+        @cookie_hash[:foo].should eql("copter")
+      end
+    end
+
+    describe "with a string" do
+      it "should add new key/value pairs to the hash" do
+        @cookie_hash.add_cookies("first=one; second=two; third")
+        @cookie_hash[:first].should == 'one'
+        @cookie_hash[:second].should == 'two'
+        @cookie_hash[:third].should == nil
+      end
+
+      it "should overwrite any existing key" do
+        @cookie_hash[:foo] = 'bar'
+        @cookie_hash.add_cookies("foo=tar")
+        @cookie_hash.length.should eql(1)
+        @cookie_hash[:foo].should eql("tar")
+      end
+    end
+
+    describe 'with other class' do
+      it "should error" do
+        lambda {
+          @cookie_hash.add_cookies(Array.new)
+        }.should raise_error
+      end
+    end
+  end
+
+  # The regexen are required because Hashes aren't ordered, so a test against
+  # a hardcoded string was randomly failing.
+  describe "#to_cookie_string" do
+    before(:each) do
+      @cookie_hash.add_cookies(:foo => "bar")
+      @cookie_hash.add_cookies(:rofl => "copter")
+      @s = @cookie_hash.to_cookie_string
+    end
+
+    it "should format the key/value pairs, delimited by semi-colons" do
+      @s.should match(/foo=bar/)
+      @s.should match(/rofl=copter/)
+      @s.should match(/^\w+=\w+; \w+=\w+$/)
+    end
+
+    it "should not include client side only cookies" do
+      @cookie_hash.add_cookies(:path => "/")
+      @s = @cookie_hash.to_cookie_string
+      @s.should_not match(/path=\//)
+    end
+
+    it "should not include client side only cookies even when attributes use camal case" do
+      @cookie_hash.add_cookies(:Path => "/")
+      @s = @cookie_hash.to_cookie_string
+      @s.should_not match(/Path=\//)
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/spec/httparty/net_digest_auth_spec.rb

@@ -0,0 +1,115 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe Net::HTTPHeader::DigestAuthenticator do
+  def setup_digest(response)
+    digest = Net::HTTPHeader::DigestAuthenticator.new("Mufasa",
+      "Circle Of Life", "GET", "/dir/index.html", response)
+    digest.stub(:random).and_return("deadbeef")
+    Digest::MD5.stub(:hexdigest) { |str| "md5(#{str})" }
+    digest
+  end
+
+  def authorization_header
+    @digest.authorization_header.join(", ")
+  end
+
+
+  context "with an opaque value in the response header" do
+    before do
+      @digest = setup_digest({
+        'www-authenticate' => 'Digest realm="myhost@testrealm.com", opaque="solid"'
+      })
+    end
+
+    it "should set opaque" do
+      authorization_header.should include(%Q(opaque="solid"))
+    end
+  end
+
+  context "without an opaque valid in the response header" do
+    before do
+      @digest = setup_digest({
+        'www-authenticate' => 'Digest realm="myhost@testrealm.com"'
+      })  
+    end
+
+    it "should not set opaque" do
+      authorization_header.should_not include(%Q(opaque=)) 
+    end
+  end
+
+  context "with specified quality of protection (qop)" do
+    before do
+      @digest = setup_digest({
+        'www-authenticate' => 'Digest realm="myhost@testrealm.com", nonce="NONCE", qop="auth"',
+      })
+    end
+
+    it "should set prefix" do
+      authorization_header.should =~ /^Digest /
+    end
+
+    it "should set username" do
+      authorization_header.should include(%Q(username="Mufasa"))
+    end
+
+    it "should set digest-uri" do
+      authorization_header.should include(%Q(uri="/dir/index.html"))
+    end
+
+    it "should set qop" do
+      authorization_header.should include(%Q(qop="auth"))
+    end
+
+    it "should set cnonce" do
+      authorization_header.should include(%Q(cnonce="md5(deadbeef)"))
+    end
+
+    it "should set nonce-count" do
+      authorization_header.should include(%Q(nc=00000001))
+    end
+
+    it "should set response" do
+      request_digest = "md5(md5(Mufasa:myhost@testrealm.com:Circle Of Life):NONCE:00000001:md5(deadbeef):auth:md5(GET:/dir/index.html))"
+      authorization_header.should include(%Q(response="#{request_digest}"))
+    end
+  end
+
+
+  context "with unspecified quality of protection (qop)" do
+    before do
+      @digest = setup_digest({
+        'www-authenticate' => 'Digest realm="myhost@testrealm.com", nonce="NONCE"',
+      })
+    end
+
+    it "should set prefix" do
+      authorization_header.should =~ /^Digest /
+    end
+
+    it "should set username" do
+      authorization_header.should include(%Q(username="Mufasa"))
+    end
+
+    it "should set digest-uri" do
+      authorization_header.should include(%Q(uri="/dir/index.html"))
+    end
+
+    it "should not set qop" do
+      authorization_header.should_not include(%Q(qop=))
+    end
+
+    it "should not set cnonce" do
+      authorization_header.should_not include(%Q(cnonce=))
+    end
+
+    it "should not set nonce-count" do
+      authorization_header.should_not include(%Q(nc=))
+    end
+
+    it "should set response" do
+      request_digest = "md5(md5(Mufasa:myhost@testrealm.com:Circle Of Life):NONCE:md5(GET:/dir/index.html))"
+      authorization_header.should include(%Q(response="#{request_digest}"))
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/spec/httparty/parser_spec.rb

@@ -0,0 +1,166 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe HTTParty::Parser do
+  describe ".SupportedFormats" do
+    it "returns a hash" do
+      HTTParty::Parser::SupportedFormats.should be_instance_of(Hash)
+    end
+  end
+
+  describe ".call" do
+    it "generates an HTTParty::Parser instance with the given body and format" do
+      HTTParty::Parser.should_receive(:new).with('body', :plain).and_return(stub(:parse => nil))
+      HTTParty::Parser.call('body', :plain)
+    end
+
+    it "calls #parse on the parser" do
+      parser = mock('Parser')
+      parser.should_receive(:parse)
+      HTTParty::Parser.stub(:new => parser)
+      parser = HTTParty::Parser.call('body', :plain)
+    end
+  end
+
+  describe ".formats" do
+    it "returns the SupportedFormats constant" do
+      HTTParty::Parser.formats.should == HTTParty::Parser::SupportedFormats
+    end
+
+    it "returns the SupportedFormats constant for subclasses" do
+      class MyParser < HTTParty::Parser
+        SupportedFormats = {"application/atom+xml" => :atom}
+      end
+      MyParser.formats.should == {"application/atom+xml" => :atom}
+    end
+  end
+
+  describe ".format_from_mimetype" do
+    it "returns a symbol representing the format mimetype" do
+      HTTParty::Parser.format_from_mimetype("text/plain").should == :plain
+    end
+
+    it "returns nil when the mimetype is not supported" do
+      HTTParty::Parser.format_from_mimetype("application/atom+xml").should be_nil
+    end
+  end
+
+  describe ".supported_formats" do
+    it "returns a unique set of supported formats represented by symbols" do
+      HTTParty::Parser.supported_formats.should == HTTParty::Parser::SupportedFormats.values.uniq
+    end
+  end
+
+  describe ".supports_format?" do
+    it "returns true for a supported format" do
+      HTTParty::Parser.stub(:supported_formats => [:json])
+      HTTParty::Parser.supports_format?(:json).should be_true
+    end
+
+    it "returns false for an unsupported format" do
+      HTTParty::Parser.stub(:supported_formats => [])
+      HTTParty::Parser.supports_format?(:json).should be_false
+    end
+  end
+
+  describe "#parse" do
+    before do
+      @parser = HTTParty::Parser.new('body', :json)
+    end
+
+    it "attempts to parse supported formats" do
+      @parser.stub(:supports_format? => true)
+      @parser.should_receive(:parse_supported_format)
+      @parser.parse
+    end
+
+    it "returns the unparsed body when the format is unsupported" do
+      @parser.stub(:supports_format? => false)
+      @parser.parse.should == @parser.body
+    end
+
+    it "returns nil for an empty body" do
+      @parser.stub(:body => '')
+      @parser.parse.should be_nil
+    end
+
+    it "returns nil for a nil body" do
+      @parser.stub(:body => nil)
+      @parser.parse.should be_nil
+    end
+
+    it "returns nil for a 'null' body" do
+      @parser.stub(:body => "null")
+      @parser.parse.should be_nil
+    end
+
+    it "returns nil for a body with spaces only" do
+      @parser.stub(:body => "   ")
+      @parser.parse.should be_nil
+    end
+  end
+
+  describe "#supports_format?" do
+    it "utilizes the class method to determine if the format is supported" do
+      HTTParty::Parser.should_receive(:supports_format?).with(:json)
+      parser = HTTParty::Parser.new('body', :json)
+      parser.send(:supports_format?)
+    end
+  end
+
+  describe "#parse_supported_format" do
+    it "calls the parser for the given format" do
+      parser = HTTParty::Parser.new('body', :json)
+      parser.should_receive(:json)
+      parser.send(:parse_supported_format)
+    end
+
+    context "when a parsing method does not exist for the given format" do
+      it "raises an exception" do
+        parser = HTTParty::Parser.new('body', :atom)
+        expect do
+          parser.send(:parse_supported_format)
+        end.to raise_error(NotImplementedError, "HTTParty::Parser has not implemented a parsing method for the :atom format.")
+      end
+
+      it "raises a useful exception message for subclasses" do
+        atom_parser = Class.new(HTTParty::Parser) do
+          def self.name; 'AtomParser'; end
+        end
+        parser = atom_parser.new 'body', :atom
+        expect do
+          parser.send(:parse_supported_format)
+        end.to raise_error(NotImplementedError, "AtomParser has not implemented a parsing method for the :atom format.")
+      end
+    end
+  end
+
+  context "parsers" do
+    subject do
+      HTTParty::Parser.new('body', nil)
+    end
+
+    it "parses xml with MultiXml" do
+      MultiXml.should_receive(:parse).with('body')
+      subject.send(:xml)
+    end
+
+    it "parses json with MultiJson" do
+      MultiJson.should_receive(:load).with('body')
+      subject.send(:json)
+    end
+
+    it "uses MultiJson.decode if MultiJson does not respond to adapter" do
+      MultiJson.should_receive(:respond_to?).with(:adapter).and_return(false)
+      MultiJson.should_receive(:decode).with('body')
+      subject.send(:json)
+    end
+
+    it "parses html by simply returning the body" do
+      subject.send(:html).should == 'body'
+    end
+
+    it "parses plain text by simply returning the body" do
+      subject.send(:plain).should == 'body'
+    end
+  end
+end