lygneo-vines 0.1.1

data/test/stream/sasl_test.rb

@@ -0,0 +1,195 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+describe Vines::Stream::SASL do
+  subject       { Vines::Stream::SASL.new(stream) }
+  let(:stream)  { MiniTest::Mock.new }
+  let(:storage) { MiniTest::Mock.new }
+  let(:romeo)   { Vines::User.new(jid: 'romeo@verona.lit') }
+
+  before do
+    def subject.log
+      Class.new do
+        def method_missing(*args)
+          # do nothing
+        end
+      end.new
+    end
+  end
+
+  describe '#plain_auth' do
+    before do
+      stream.expect :domain, 'verona.lit'
+    end
+
+    it 'fails with empty input' do
+      -> { subject.plain_auth(nil) }.must_raise Vines::SaslErrors::IncorrectEncoding
+      -> { subject.plain_auth('') }.must_raise Vines::SaslErrors::NotAuthorized
+    end
+
+    it 'fails with plain text' do
+      -> { subject.plain_auth('bogus') }.must_raise Vines::SaslErrors::IncorrectEncoding
+    end
+
+    it 'fails with incorrectly encoded base64 text' do
+      -> { subject.plain_auth('=dmVyb25hLmxpdA==') }.must_raise Vines::SaslErrors::IncorrectEncoding
+      -> { subject.plain_auth("dmVyb25hLmxpdA==\n") }.must_raise Vines::SaslErrors::IncorrectEncoding
+    end
+
+    it 'fails when authzid does not match authcid username' do
+      encoded = Base64.strict_encode64("juliet@verona.lit\x00romeo\x00secr3t")
+      -> { subject.plain_auth(encoded) }.must_raise Vines::SaslErrors::InvalidAuthzid
+      stream.verify
+    end
+
+    it 'fails when authzid does not match authcid domain' do
+      encoded = Base64.strict_encode64("romeo@wonderland.lit\x00romeo\x00secr3t")
+      -> { subject.plain_auth(encoded) }.must_raise Vines::SaslErrors::InvalidAuthzid
+      stream.verify
+    end
+
+    it 'fails when username and password are missing' do
+      encoded = Base64.strict_encode64("\x00\x00")
+      -> { subject.plain_auth(encoded) }.must_raise Vines::SaslErrors::NotAuthorized
+    end
+
+    it 'fails when username is missing' do
+      encoded = Base64.strict_encode64("\x00\x00secr3t")
+      -> { subject.plain_auth(encoded) }.must_raise Vines::SaslErrors::NotAuthorized
+    end
+
+    it 'fails when password is missing with delimiter' do
+      encoded = Base64.strict_encode64("\x00romeo\x00")
+      -> { subject.plain_auth(encoded) }.must_raise Vines::SaslErrors::NotAuthorized
+    end
+
+    it 'fails when password is missing' do
+      encoded = Base64.strict_encode64("\x00romeo")
+      -> { subject.plain_auth(encoded) }.must_raise Vines::SaslErrors::NotAuthorized
+    end
+
+    it 'fails with invalid jid' do
+      encoded = Base64.strict_encode64("\x00#{'a' * 1024}\x00secr3t")
+      -> { subject.plain_auth(encoded) }.must_raise Vines::SaslErrors::NotAuthorized
+      stream.verify
+    end
+
+    it 'fails with invalid password' do
+      storage.expect :authenticate, nil, [romeo.jid, 'secr3t']
+      stream.expect :storage, storage
+
+      encoded = Base64.strict_encode64("\x00romeo\x00secr3t")
+      -> { subject.plain_auth(encoded) }.must_raise Vines::SaslErrors::NotAuthorized
+
+      stream.verify
+      storage.verify
+    end
+
+    it 'passes with valid password' do
+      storage.expect :authenticate, romeo, [romeo.jid, 'secr3t']
+      stream.expect :storage, storage
+
+      encoded = Base64.strict_encode64("\x00romeo\x00secr3t")
+      subject.plain_auth(encoded).must_equal romeo
+
+      stream.verify
+      storage.verify
+    end
+
+    it 'passes with valid password and unicode jid' do
+      user = Vines::User.new(jid: 'piñata@verona.lit')
+      storage.expect :authenticate, user, [user.jid, 'secr3t']
+      stream.expect :storage, storage
+
+      encoded = Base64.strict_encode64("\x00piñata\x00secr3t")
+      subject.plain_auth(encoded).must_equal user
+
+      stream.verify
+      storage.verify
+    end
+
+    it 'passes with valid password and authzid provided by strophe and blather' do
+      storage.expect :authenticate, romeo, [romeo.jid, 'secr3t']
+      stream.expect :storage, storage
+
+      encoded = Base64.strict_encode64("romeo@Verona.LIT\x00romeo\x00secr3t")
+      subject.plain_auth(encoded).must_equal romeo
+
+      stream.verify
+      storage.verify
+    end
+
+    it 'passes with valid password and authzid provided by smack' do
+      storage.expect :authenticate, romeo, [romeo.jid, 'secr3t']
+      stream.expect :storage, storage
+
+      encoded = Base64.strict_encode64("romeo\x00romeo\x00secr3t")
+      subject.plain_auth(encoded).must_equal romeo
+
+      stream.verify
+      storage.verify
+    end
+
+    it 'raises temporary-auth-failure when storage backend fails' do
+      storage = Class.new do
+        def authenticate(*args)
+          raise 'boom'
+        end
+      end.new
+
+      stream.expect :storage, storage
+      encoded = Base64.strict_encode64("\x00romeo\x00secr3t")
+      -> { subject.plain_auth(encoded) }.must_raise Vines::SaslErrors::TemporaryAuthFailure
+      stream.verify
+    end
+  end
+
+  describe '#external_auth' do
+    it 'fails with empty input' do
+      stream.expect :remote_domain, 'verona.lit'
+      -> { subject.external_auth(nil) }.must_raise Vines::SaslErrors::IncorrectEncoding
+      -> { subject.external_auth('') }.must_raise Vines::SaslErrors::InvalidAuthzid
+      stream.verify
+    end
+
+    it 'fails with plain text' do
+      -> { subject.external_auth('bogus') }.must_raise Vines::SaslErrors::IncorrectEncoding
+      stream.verify
+    end
+
+    it 'fails with incorrectly encoded base64 text' do
+      -> { subject.external_auth('=dmVyb25hLmxpdA==') }.must_raise Vines::SaslErrors::IncorrectEncoding
+      -> { subject.external_auth("dmVyb25hLmxpdA==\n") }.must_raise Vines::SaslErrors::IncorrectEncoding
+      stream.verify
+    end
+
+    it 'passes with empty authzid and matching cert' do
+      stream.expect :remote_domain, 'verona.lit'
+      stream.expect :cert_domain_matches?, true, ['verona.lit']
+      subject.external_auth('=').must_equal true
+      stream.verify
+    end
+
+    it 'fails with empty authzid and non-matching cert' do
+      stream.expect :remote_domain, 'verona.lit'
+      stream.expect :cert_domain_matches?, false, ['verona.lit']
+      -> { subject.external_auth('=') }.must_raise Vines::SaslErrors::NotAuthorized
+      stream.verify
+    end
+
+    it 'fails when authzid does not match stream from address' do
+      stream.expect :remote_domain, 'not.verona.lit'
+      -> { subject.external_auth('dmVyb25hLmxpdA==') }.must_raise Vines::SaslErrors::InvalidAuthzid
+      stream.verify
+    end
+
+    it 'passes when authzid matches stream from address' do
+      stream.expect :remote_domain, 'verona.lit'
+      stream.expect :remote_domain, 'verona.lit'
+      stream.expect :cert_domain_matches?, true, ['verona.lit']
+      subject.external_auth('dmVyb25hLmxpdA==').must_equal true
+      stream.verify
+    end
+  end
+end

data/test/stream/server/auth_test.rb

@@ -0,0 +1,61 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+describe Vines::Stream::Server::Auth do
+  # disable logging for tests
+  Class.new.extend(Vines::Log).log.level = Logger::FATAL
+
+  subject      { Vines::Stream::Server::Auth.new(stream) }
+  let(:stream) { MiniTest::Mock.new }
+
+  before do
+    class << stream
+      attr_accessor :remote_domain
+    end
+    stream.remote_domain = 'wonderland.lit'
+  end
+
+  describe 'when given a valid authzid' do
+    before do
+      stream.expect :cert_domain_matches?, true, ['wonderland.lit']
+      stream.expect :write, nil, ['<success xmlns="urn:ietf:params:xml:ns:xmpp-sasl"/>']
+      stream.expect :advance, nil, [Vines::Stream::Server::FinalRestart]
+      stream.expect :reset, nil
+      stream.expect :authentication_mechanisms, ['EXTERNAL']
+    end
+
+    it 'passes external auth with empty authzid' do
+      node = external('=')
+      subject.node(node)
+      stream.verify
+    end
+
+    it 'passes external auth with authzid matching from domain' do
+      node = external(Base64.strict_encode64('wonderland.lit'))
+      subject.node(node)
+      stream.verify
+    end
+  end
+
+  describe 'when given an invalid authzid' do
+    before do
+      stream.expect :write, nil, ['</stream:stream>']
+      stream.expect :close_connection_after_writing, nil
+      stream.expect :error, nil, [Vines::SaslErrors::InvalidAuthzid]
+      stream.expect :authentication_mechanisms, ['EXTERNAL']
+    end
+
+    it 'fails external auth with mismatched from domain' do
+      node = external(Base64.strict_encode64('verona.lit'))
+      subject.node(node)
+      stream.verify
+    end
+  end
+
+  private
+
+  def external(authzid)
+    node(%Q{<auth xmlns="urn:ietf:params:xml:ns:xmpp-sasl" mechanism="EXTERNAL">#{authzid}</auth>})
+  end
+end

data/test/stream/server/outbound/auth_test.rb

@@ -0,0 +1,75 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+describe Vines::Stream::Server::Outbound::Auth do
+  before do
+    @stream = MiniTest::Mock.new
+    @state = Vines::Stream::Server::Outbound::Auth.new(@stream)
+  end
+
+  def test_invalid_element
+    node = node('<message/>')
+    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_invalid_sasl_element
+    node = node(%Q{<message xmlns="#{Vines::NAMESPACES[:sasl]}"/>})
+    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_missing_namespace
+    node = node('<stream:features/>')
+    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_invalid_namespace
+    node = node('<stream:features xmlns="bogus"/>')
+    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_missing_mechanisms
+    node = node(%Q{<stream:features xmlns:stream="http://etherx.jabber.org/streams"/>})
+    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_missing_mechanisms_namespace
+    node = node(%Q{<stream:features xmlns:stream="http://etherx.jabber.org/streams"><mechanisms/></stream:features>})
+    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_missing_mechanism
+    mechanisms = %q{<mechanisms xmlns="urn:ietf:params:xml:ns:xmpp-sasl"/>}
+    node = node(%Q{<stream:features xmlns:stream="http://etherx.jabber.org/streams">#{mechanisms}</stream:features>})
+    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_missing_mechanism_text
+    mechanisms = %q{<mechanisms xmlns="urn:ietf:params:xml:ns:xmpp-sasl"><mechanism></mechanism></mechanisms>}
+    node = node(%Q{<stream:features xmlns:stream="http://etherx.jabber.org/streams">#{mechanisms}</stream:features>})
+    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_invalid_mechanism_text
+    mechanisms = %q{<mechanisms xmlns="urn:ietf:params:xml:ns:xmpp-sasl"><mechanism>BOGUS</mechanism></mechanisms>}
+    node = node(%Q{<stream:features xmlns:stream="http://etherx.jabber.org/streams">#{mechanisms}</stream:features>})
+    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_valid_mechanism
+    @stream.expect(:domain, 'wonderland.lit')
+    expected = %Q{<auth xmlns="urn:ietf:params:xml:ns:xmpp-sasl" mechanism="EXTERNAL">d29uZGVybGFuZC5saXQ=</auth>}
+    @stream.expect(:write, nil, [expected])
+    @stream.expect(:advance, nil, [Vines::Stream::Server::Outbound::AuthResult.new(@stream)])
+    mechanisms = %q{<mechanisms xmlns="urn:ietf:params:xml:ns:xmpp-sasl"><mechanism>EXTERNAL</mechanism></mechanisms>}
+    node = node(%Q{<stream:features xmlns:stream="http://etherx.jabber.org/streams">#{mechanisms}</stream:features>})
+    @state.node(node)
+    assert @stream.verify
+  end
+
+  private
+
+  def node(xml)
+    Nokogiri::XML(xml).root
+  end
+end

data/test/stream/server/ready_test.rb

@@ -0,0 +1,98 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+describe Vines::Stream::Server::Ready do
+  subject      { Vines::Stream::Server::Ready.new(stream, nil) }
+  let(:stream) { MiniTest::Mock.new }
+
+  SERVER_STANZAS = []
+
+  before do
+    def subject.to_stanza(node)
+      Vines::Stanza.from_node(node, stream).tap do |stanza|
+        def stanza.process
+          SERVER_STANZAS << self
+        end if stanza
+      end
+    end
+  end
+
+  after do
+    SERVER_STANZAS.clear
+  end
+
+  it 'processes a valid node' do
+    config = MiniTest::Mock.new
+    config.expect(:local_jid?, true, [Vines::JID.new('romeo@verona.lit')])
+
+    stream.expect(:config, config)
+    stream.expect(:remote_domain, 'wonderland.lit')
+    stream.expect(:domain, 'verona.lit')
+    stream.expect(:user=, nil, [Vines::User.new(jid: 'alice@wonderland.lit')])
+
+    node = node(%Q{<message from="alice@wonderland.lit" to="romeo@verona.lit"/>})
+    subject.node(node)
+    assert_equal 1, SERVER_STANZAS.size
+    assert stream.verify
+    assert config.verify
+  end
+
+  it 'raises unsupported-stanza-type stream error' do
+    node = node('<bogus/>')
+    -> { subject.node(node) }.must_raise Vines::StreamErrors::UnsupportedStanzaType
+    assert SERVER_STANZAS.empty?
+    assert stream.verify
+  end
+
+  it 'raises improper-addressing stream error when to address is missing' do
+    node = node(%Q{<message from="alice@wonderland.lit"/>})
+    -> { subject.node(node) }.must_raise Vines::StreamErrors::ImproperAddressing
+    assert SERVER_STANZAS.empty?
+    assert stream.verify
+  end
+
+  it 'raises jid-malformed stanza error when to address is invalid' do
+    node = node(%Q{<message from="alice@wonderland.lit" to=" "/>})
+    -> { subject.node(node) }.must_raise Vines::StanzaErrors::JidMalformed
+    assert SERVER_STANZAS.empty?
+    assert stream.verify
+  end
+
+  it 'raises improper-addressing stream error' do
+    node = node(%Q{<message to="romeo@verona.lit"/>})
+    -> { subject.node(node) }.must_raise Vines::StreamErrors::ImproperAddressing
+    assert SERVER_STANZAS.empty?
+    assert stream.verify
+  end
+
+  it 'raises jid-malformed stanza error for invalid from address' do
+    node = node(%Q{<message from=" " to="romeo@verona.lit"/>})
+    -> { subject.node(node) }.must_raise Vines::StanzaErrors::JidMalformed
+    assert SERVER_STANZAS.empty?
+    assert stream.verify
+  end
+
+  it 'raises invalid-from stream error' do
+    stream.expect(:remote_domain, 'wonderland.lit')
+    node = node(%Q{<message from="alice@bogus.lit" to="romeo@verona.lit"/>})
+    -> { subject.node(node) }.must_raise Vines::StreamErrors::InvalidFrom
+    assert SERVER_STANZAS.empty?
+    assert stream.verify
+  end
+
+  it 'raises host-unknown stream error' do
+    stream.expect(:remote_domain, 'wonderland.lit')
+    stream.expect(:domain, 'verona.lit')
+    node = node(%Q{<message from="alice@wonderland.lit" to="romeo@bogus.lit"/>})
+    -> { subject.node(node) }.must_raise Vines::StreamErrors::HostUnknown
+    assert SERVER_STANZAS.empty?
+    assert stream.verify
+  end
+
+  private
+
+  def node(xml)
+    Nokogiri::XML(xml).root
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+
+require 'tmpdir'
+require 'vines'
+require 'ext/nokogiri'
+require 'minitest/autorun'
+
+class MiniTest::Spec
+
+  # Build an <iq> xml node with the given attributes. This is useful as a
+  # quick way to build a node to use as expected stanza output from a
+  # Stream#write call.
+  #
+  # options - The Hash of xml attributes to include on the iq element. Attribute
+  #           values of nil or empty? are excluded from the generated element.
+  #           :body - The String xml content to include in the iq element.
+  #
+  # Examples
+  #
+  #   iq(from: from, id: 42, to: to, type: 'result', body: card)
+  #
+  # Returns a Nokogiri::XML::Node.
+  def iq(options)
+    body = options.delete(:body)
+    options.delete_if {|k, v| v.nil? || v.to_s.empty? }
+    attrs = options.map {|k, v| "#{k}=\"#{v}\"" }.join(' ')
+    node("<iq #{attrs}>#{body}</iq>")
+  end
+
+  # Parse xml into a nokogiri node. Strip excessive whitespace from the xml
+  # content before parsing because it affects comparisons in MiniTest::Mock
+  # expectations.
+  #
+  # xml - The String of xml content to parse.
+  #
+  # Returns a Nokogiri::XML::Node.
+  def node(xml)
+    xml = xml.strip.gsub(/\n|\s{2,}/, '')
+    Nokogiri::XML(xml).root
+  end
+end
+

data/test/token_bucket_test.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+describe Vines::TokenBucket do
+  subject { Vines::TokenBucket.new(10, 1) }
+
+  it 'raises with invalid capacity and rate values' do
+    -> { Vines::TokenBucket.new(0, 1) }.must_raise ArgumentError
+    -> { Vines::TokenBucket.new(1, 0) }.must_raise ArgumentError
+    -> { Vines::TokenBucket.new(-1, 1) }.must_raise ArgumentError
+    -> { Vines::TokenBucket.new(1, -1) }.must_raise ArgumentError
+  end
+
+  it 'does not allow taking a negative number of tokens' do
+    -> { subject.take(-1) }.must_raise ArgumentError
+  end
+
+  it 'does not allow taking more tokens than its capacity' do
+    refute subject.take(11)
+  end
+
+  it 'allows taking all tokens, but no more' do
+    assert subject.take(10)
+    refute subject.take(1)
+  end
+
+  it 'refills over time' do
+    assert subject.take(10)
+    refute subject.take(1)
+    Time.stub(:new, Time.now + 1) do
+      assert subject.take(1)
+      refute subject.take(1)
+    end
+  end
+
+  it 'does not refill over capacity' do
+    assert subject.take(10)
+    refute subject.take(1)
+    Time.stub(:new, Time.now + 15) do
+      refute subject.take(11)
+    end
+  end
+end

data/test/user_test.rb

@@ -0,0 +1,96 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+describe Vines::User do
+  subject { Vines::User.new(jid: 'alice@wonderland.lit', name: 'Alice', password: 'secr3t') }
+
+  describe 'user equality checks' do
+    let(:alice)  { Vines::User.new(jid: 'alice@wonderland.lit') }
+    let(:hatter) { Vines::User.new(jid: 'hatter@wonderland.lit') }
+
+    it 'uses class in equality check' do
+      (subject <=> 42).must_be_nil
+    end
+
+    it 'is equal to itself' do
+      assert subject == subject
+      assert subject.eql?(subject)
+      assert subject.hash == subject.hash
+    end
+
+    it 'is equal to another user with the same jid' do
+      assert subject == alice
+      assert subject.eql?(alice)
+      assert subject.hash == alice.hash
+    end
+
+    it 'is not equal to a different jid' do
+      refute subject == hatter
+      refute subject.eql?(hatter)
+      refute subject.hash == hatter.hash
+    end
+  end
+
+  describe 'initialize' do
+    it 'raises when not given a jid' do
+      -> { Vines::User.new }.must_raise ArgumentError
+      -> { Vines::User.new(jid: '') }.must_raise ArgumentError
+    end
+
+    it 'has an empty roster' do
+      subject.roster.wont_be_nil
+      subject.roster.size.must_equal 0
+    end
+  end
+
+  describe '#update_from' do
+    let(:updated) { Vines::User.new(jid: 'alice2@wonderland.lit', name: 'Alice 2', password: "secr3t 2") }
+
+    before do
+      subject.roster << Vines::Follower.new(jid: 'hatter@wonderland.lit', name: "Hatter")
+      updated.roster << Vines::Follower.new(jid: 'cat@wonderland.lit', name: "Cheshire")
+    end
+
+    it 'updates jid, name, and password' do
+      subject.update_from(updated)
+      subject.jid.to_s.must_equal 'alice@wonderland.lit'
+      subject.name.must_equal 'Alice 2'
+      subject.password.must_equal 'secr3t 2'
+    end
+
+    it 'overwrites the entire roster' do
+      subject.update_from(updated)
+      subject.roster.size.must_equal 1
+      subject.roster.first.must_equal updated.roster.first
+    end
+
+    it 'clones roster entries' do
+      subject.update_from(updated)
+      updated.roster.first.name = 'Updated Follower 2'
+      subject.roster.first.name.must_equal 'Cheshire'
+    end
+  end
+
+  describe '#to_roster_xml' do
+    let(:expected) do
+      node(%q{
+        <iq id="42" type="result">
+          <query xmlns="jabber:iq:roster">
+            <item jid="a@wonderland.lit" name="Follower 1" subscription="none"><group>A</group><group>B</group></item>
+            <item jid="b@wonderland.lit" name="Follower 2" subscription="none"><group>C</group></item>
+          </query>
+        </iq>
+      })
+    end
+
+    before do
+      subject.roster << Vines::Follower.new(jid: 'b@wonderland.lit', name: "Follower 2", groups: %w[C])
+      subject.roster << Vines::Follower.new(jid: 'a@wonderland.lit', name: "Follower 1", groups: %w[B A])
+    end
+
+    it 'sorts group names' do
+      subject.to_roster_xml(42).must_equal expected
+    end
+  end
+end

data/vines.gemspec

@@ -0,0 +1,30 @@
+require './lib/vines/version'
+
+Gem::Specification.new do |s|
+  s.name         = 'lygneo-vines'
+  s.version      = Vines::VERSION
+  s.summary      = %q[Lygneo-vines is a Vines fork build for lygneo integration.]
+  s.description  = %q[Lygneo-vines is a Vines fork build for lygneo integration. DO NOT use it unless you know what you are doing!]
+
+  s.authors      = ['David Graham','Lukas Matt']
+  s.email        = ['david@negativecode.com','lukas@zauberstuhl.de']
+  s.homepage     = 'https://lygneofoundation.org'
+  s.license      = 'MIT'
+
+  s.files        = Dir['[A-Z]*', 'vines.gemspec', '{bin,lib,conf,web}/**/*'] - ['Gemfile.lock']
+  s.test_files   = Dir['test/**/*']
+  s.executables  = %w[vines]
+  s.require_path = 'lib'
+
+  s.add_dependency 'bcrypt', '~> 3.1'
+  s.add_dependency 'em-hiredis', '~> 0.1.1'
+  s.add_dependency 'eventmachine', '~> 1.0.3'
+  s.add_dependency 'http_parser.rb', '~> 0.5.3'
+  s.add_dependency 'net-ldap', '~> 0.3.1'
+  s.add_dependency 'nokogiri', '>= 1.5.10'
+
+  s.add_development_dependency 'minitest', '~> 5.3'
+  s.add_development_dependency 'rake', '~> 10.3'
+
+  s.required_ruby_version = '>= 1.9.3'
+end