etcd-rb 1.0.0.pre0

data/README.md

@@ -0,0 +1,50 @@
+# Ruby CQL3 driver
+
+[![Build Status](https://travis-ci.org/iconara/etcd-rb.png?branch=master)](https://travis-ci.org/iconara/etcd-rb)
+[![Coverage Status](https://coveralls.io/repos/iconara/etcd-rb/badge.png?branch=master)](https://coveralls.io/r/iconara/etcd-rb)
+
+# Requirements
+
+A modern Ruby, compatible with 1.9.3 or later. Continously tested with MRI 1.9.3, 2.0.0 and JRuby 1.7.x.
+
+# Installation
+
+    gem install etcd-rb --prerelease
+
+# Quick start
+
+```ruby
+require 'etcd'
+
+client = Etcd::Client.new
+client.set('/foo', 'bar')
+client.get('/foo')
+```
+
+See the full [API documentation](http://rubydoc.info/gems/etcd-rb/frames) for more.
+
+# Changelog & versioning
+
+Check out the [releases on GitHub](https://github.com/iconara/etcd-rb/releases). Version numbering follows the [semantic versioning](http://semver.org/) scheme.
+
+# How to contribute
+
+Fork the repository, make your changes in a topic branch that branches off from the right place in the history (HEAD isn't necessarily always right), make your changes and finally submit a pull request.
+
+Follow the style of the existing code, make sure that existing tests pass, and that everything new has good test coverage. Put some effort into writing clear and concise commit messages, and write a good pull request description.
+
+It takes time to understand other people's code, and even more time to understand a patch, so do as much as you can to make the maintainers' work easier. Be prepared for rejection, many times a feature is already planned, or the proposed design would be in the way of other planned features, or the maintainers' just feel that it will be faster to implement the features themselves than to try to integrate your patch.
+
+Feel free to open a pull request before the feature is finished, that way you can have a conversation with the maintainers' during the development, and you can make adjustments to the design as you go along instead of having your whole feature rejected because of reasons such as those above. If you do, please make it clear that the pull request is a work in progress, or a request for comment.
+
+Always remember that the maintainers' work on this project in their free time and that they don't work for you, or for your benefit. They have no obligation to do what you think is right -- but if you're nice they might anyway.
+
+# Copyright
+
+Copyright 2013 Theo Hultberg/Iconara
+
+_Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License You may obtain a copy of the License at_
+
+[http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)
+
+_Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License._

data/lib/etcd.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+module Etcd
+  EtcdError = Class.new(StandardError)
+end
+
+require 'etcd/version'
+require 'etcd/client'

data/lib/etcd/client.rb

@@ -0,0 +1,346 @@
+# encoding: utf-8
+
+require 'time'
+require 'thread'
+require 'httpclient'
+require 'multi_json'
+
+
+module Etcd
+  # A client for `etcd`. Implements all core operations (`get`, `set`, `delete`
+  # and `watch`) and features (TTL, atomic test-and-set, listing directories,
+  # etc).
+  #
+  # In addition to the core operations there are a few convenience methods for
+  # doing test-and-set (a.k.a. compare-and-swap, atomic update), and continuous
+  # watching.
+  #
+  # @note All methods that take a key or prefix as argument will prepend a slash
+  #   to the key if it does not start with slash.
+  #
+  # @example Basic usage
+  #   client = Etcd::Client.new
+  #   client.set('/foo/bar', 'baz')
+  #   client.get('/foo/bar') # => 'baz'
+  #   client.delete('/foo/bar') # => 'baz'
+  #
+  # @example Make a key expire automatically after 5s
+  #   client.set('/foo', 'bar', ttl: 5)
+  #
+  # @example Atomic updates
+  #   client.set('/foo/bar', 'baz')
+  #   # ...
+  #   if client.update('/foo/bar', 'qux', 'baz')
+  #     puts 'Nobody changed our data'
+  #   end
+  #
+  # @example Listing a directory
+  #   client.set('/foo/bar', 'baz')
+  #   client.set('/foo/qux', 'fizz')
+  #   client.get('/foo') # => {'/foo/bar' => 'baz', '/foo/qux' => 'fizz'}
+  #
+  # @example Getting info for a key
+  #   client.set('/foo', 'bar', ttl: 5)
+  #   client.info('/foo') # => {:key => '/foo',
+  #                       #     :value => '/bar',
+  #                       #     :expires => Time.utc(...),
+  #                       #     :ttl => 4}
+  #
+  # @example Observing changes to a key
+  #   observer = client.observe('/foo') do |value, key|
+  #     # This will be run asynchronously
+  #     puts "The key #{key}" changed to #{value}"
+  #   end
+  #   client.set('/foo/bar', 'baz') # "The key /foo/bar changed to baz" is printed
+  #   client.set('/foo/qux', 'fizz') # "The key /foo/qux changed to fizz" is printed
+  #   # stop receiving change notifications
+  #   observer.cancel
+  # 
+  class Client
+    # Creates a new `etcd` client.
+    #
+    # @param [Hash] options
+    # @option options [String] :host ('127.0.0.1') The etcd host to connect to
+    # @option options [String] :port (4001) The port to connect to
+    def initialize(options={})
+      @host = options[:host] || '127.0.0.1'
+      @port = options[:port] || 4001
+      @http_client = HTTPClient.new(agent_name: "etcd-rb/#{VERSION}")
+    end
+
+    # Sets the value of a key.
+    #
+    # Accepts an optional `:ttl` which is the number of seconds that the key
+    # should live before being automatically deleted.
+    #
+    # @param key [String] the key to set
+    # @param value [String] the value to set
+    # @param options [Hash]
+    # @option options [Fixnum] :ttl (nil) an optional time to live (in seconds)
+    #   for the key
+    # @return [String] The previous value (if any)
+    def set(key, value, options={})
+      body = {:value => value}
+      if ttl = options[:ttl]
+        body[:ttl] = ttl
+      end
+      response = @http_client.post(uri(key), body)
+      data = MultiJson.load(response.body)
+      data[S_PREV_VALUE]
+    end
+
+    # Atomically sets the value for a key if the current value for the key
+    # matches the specified expected value.
+    #
+    # Returns `true` when the operation succeeds, i.e. when the specified
+    # expected value matches the current value. Returns `false` otherwise.
+    #
+    # Accepts an optional `:ttl` which is the number of seconds that the key
+    # should live before being automatically deleted.
+    #
+    # @param key [String] the key to set
+    # @param value [String] the value to set
+    # @param expected_value [String] the value to compare to the current value
+    # @param options [Hash]
+    # @option options [Fixnum] :ttl (nil) an optional time to live (in seconds)
+    #   for the key
+    # @return [true, false] whether or not the operation succeeded
+    def update(key, value, expected_value, options={})
+      body = {:value => value, :prevValue => expected_value}
+      if ttl = options[:ttl]
+        body[:ttl] = ttl
+      end
+      response = @http_client.post(uri(key), body)
+      response.status == 200
+    end
+
+    # Gets the value or values for a key.
+    #
+    # If the key represents a directory with direct decendants (e.g. "/foo" for
+    # "/foo/bar") a hash of keys and values will be returned.
+    #
+    # @param key [String] the key or prefix to retrieve
+    # @return [String, Hash] the value for the key, or a hash of keys and values
+    #   when the key is a prefix.
+    def get(key)
+      response = @http_client.get(uri(key))
+      if response.status == 200
+        data = MultiJson.load(response.body)
+        if data.is_a?(Array)
+          data.each_with_object({}) do |e, acc|
+            acc[e[S_KEY]] = e[S_VALUE]
+          end
+        else
+          data[S_VALUE]
+        end
+      else
+        nil
+      end
+    end
+
+    # Returns info about a key, such as TTL, expiration and index.
+    #
+    # For keys with values the returned hash will include `:key`, `:value` and
+    # `:index`. Additionally for keys with a TTL set there will be a `:ttl` and
+    # `:expiration` (as a UTC `Time`).
+    #
+    # For keys that represent directories with no direct decendants (e.g. "/foo"
+    # for "/foo/bar/baz") the `:dir` key will have the value `true`.
+    #
+    # For keys that represent directories with direct decendants (e.g. "/foo"
+    # for "/foo/bar") a hash of keys and info will be returned.
+    #
+    # @param key [String] the key or prefix to retrieve
+    # @return [Hash] a with info about the key, the exact contents depend on
+    #   what kind of key it is.
+    def info(key)
+      response = @http_client.get(uri(key))
+      if response.status == 200
+        data = MultiJson.load(response.body)
+        if data.is_a?(Array)
+          data.each_with_object({}) do |d, acc|
+            info = extract_info(d)
+            info.delete(:action)
+            acc[info[:key]] = info
+          end
+        else
+          info = extract_info(data)
+          info.delete(:action)
+          info
+        end
+      else
+        nil
+      end
+    end
+
+    # Remove a key and its value.
+    #
+    # The previous value is returned, or `nil` if the key did not exist.
+    #
+    # @param key [String] the key to remove
+    # @return [String] the previous value, if any
+    def delete(key)
+      response = @http_client.delete(uri(key))
+      if response.status == 200
+        data = MultiJson.load(response.body)
+        data[S_PREV_VALUE]
+      else
+        nil
+      end
+    end
+
+    # Returns true if the specified key exists.
+    #
+    # This is a convenience method and equivalent to calling {#get} and checking
+    # if the value is `nil`.
+    #
+    # @return [true, false] whether or not the specified key exists
+    def exists?(key)
+      !!get(key)
+    end
+
+    # Watches a key or prefix and calls the given block when with any changes.
+    #
+    # This method will block until the server replies. There is no way to cancel
+    # the call.
+    #
+    # The parameters to the block are the value, the key and a hash of
+    # additional info. The info will contain the `:action` that caused the
+    # change (`:set`, `:delete` etc.), the `:key`, the `:value`, the `:index`,
+    # `:new_key` with the value `true` when a new key was created below the
+    # watched prefix, `:previous_value`, if any, `:ttl` and `:expiration` if
+    # applicable.
+    #
+    # The reason why the block parameters are in the order`value`, `key` instead
+    # of `key`, `value` is because you almost always want to get the new value
+    # when you watch, but not always the key, and most often not the info. With
+    # this order you can leave out the parameters you don't need.
+    #
+    # @param prefix [String] the key or prefix to watch
+    # @param options [Hash]
+    # @option options [Fixnum] :index (nil) the index to start watching from
+    # @yieldparam [String] value the value of the key that changed
+    # @yieldparam [String] key the key that changed
+    # @yieldparam [Hash] info the info for the key that changed
+    # @return [Object] the result of the given block
+    def watch(prefix, options={})
+      parameters = {}
+      if index = options[:index]
+        parameters[:index] = index
+      end
+      response = @http_client.get(uri(prefix, S_WATCH), parameters)
+      data = MultiJson.load(response.body)
+      info = extract_info(data)
+      yield info[:value], info[:key], info
+    end
+
+    # Sets up a continuous watch of a key or prefix.
+    #
+    # This method works like {#watch} (which is used behind the scenes), but
+    # will re-watch the key or prefix after receiving a change notificiation.
+    #
+    # When re-watching the index of the previous change notification is used,
+    # so no subsequent changes will be lost while a change is being processed.
+    #
+    # Unlike {#watch} this method as asynchronous. The watch handler runs in a
+    # separate thread (currently a new thread is created for each invocation,
+    # keep this in mind if you need to watch many different keys), and can be
+    # cancelled by calling `#cancel` on the returned object.
+    #
+    # Because of implementation details the watch handler thread will not be
+    # stopped directly when you call `#cancel`. The thread will be blocked until
+    # the next change notification (which will be ignored). This will have very
+    # little effect on performance since the thread will not be runnable. Unless
+    # you're creating lots of observers it should not matter. If you want to
+    # make sure you wait for the thread to stop you can call `#join` on the
+    # returned object.
+    #
+    # @example Creating and cancelling an observer
+    #   observer = client.observe('/foo') do |value|
+    #     # do something on changes
+    #   end
+    #   # ...
+    #   observer.cancel
+    #
+    # @return [#cancel, #join] an observer object which you can call cancel and
+    #   join on
+    def observe(prefix, &handler)
+      Observer.new(self, prefix, handler).tap(&:run)
+    end
+
+    private
+
+    S_KEY = 'key'.freeze
+    S_KEYS = 'keys'.freeze
+    S_VALUE = 'value'.freeze
+    S_INDEX = 'index'.freeze
+    S_EXPIRATION = 'expiration'.freeze
+    S_TTL = 'ttl'.freeze
+    S_NEW_KEY = 'newKey'.freeze
+    S_DIR = 'dir'.freeze
+    S_PREV_VALUE = 'prevValue'.freeze
+    S_ACTION = 'action'.freeze
+    S_WATCH = 'watch'.freeze
+
+    S_SLASH = '/'.freeze
+
+    def uri(key, action=S_KEYS)
+      key = "/#{key}" unless key.start_with?(S_SLASH)
+      "http://#{@host}:#{@port}/v1/#{action}#{key}"
+    end
+
+    def extract_info(data)
+      info = {
+        :key => data[S_KEY],
+        :value => data[S_VALUE],
+        :index => data[S_INDEX],
+      }
+      expiration_s = data[S_EXPIRATION]
+      ttl = data[S_TTL]
+      previous_value = data[S_PREV_VALUE]
+      action_s = data[S_ACTION]
+      info[:expiration] = Time.iso8601(expiration_s) if expiration_s
+      info[:ttl] = ttl if ttl
+      info[:new_key] = data[S_NEW_KEY] if data.include?(S_NEW_KEY)
+      info[:dir] = data[S_DIR] if data.include?(S_DIR)
+      info[:previous_value] = previous_value if previous_value
+      info[:action] = action_s.downcase.to_sym if action_s
+      info
+    end
+
+    # @private
+    class Observer
+      def initialize(client, prefix, handler)
+        @client = client
+        @prefix = prefix
+        @handler = handler
+      end
+
+      def run
+        @running = true
+        index = nil
+        @thread = Thread.start do
+          while @running
+            @client.watch(@prefix, index: index) do |value, key, info|
+              if @running
+                index = info[:index]
+                @handler.call(value, key, info)
+              end
+            end
+          end
+        end
+        self
+      end
+
+      def cancel
+        @running = false
+        self
+      end
+
+      def join
+        @thread.join
+        self
+      end
+    end
+  end
+end

data/lib/etcd/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module Etcd
+  VERSION = '1.0.0.pre0'.freeze
+end

data/spec/etcd/client_spec.rb

@@ -0,0 +1,345 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Etcd
+  describe Client do
+    let :client do
+      described_class.new(host: host, port: port)
+    end
+
+    let :host do
+      'example.com'
+    end
+
+    let :port do
+      rand(2**16)
+    end
+
+    let :base_uri do
+      "http://#{host}:#{port}/v1"
+    end
+
+    describe '#get' do
+      before do
+        stub_request(:get, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({'value' => 'bar'}))
+      end
+
+      it 'sends a GET request to retrieve the value for a key' do
+        client.get('/foo')
+        WebMock.should have_requested(:get, "#{base_uri}/keys/foo")
+      end
+
+      it 'prepends a slash to keys when necessary' do
+        client.get('foo')
+        WebMock.should have_requested(:get, "#{base_uri}/keys/foo")
+      end
+
+      it 'parses the response and returns the value' do
+        client.get('/foo').should == 'bar'
+      end
+
+      it 'returns nil if when the key does not exist' do
+        stub_request(:get, "#{base_uri}/keys/foo").to_return(status: 404, body: 'Not found')
+        client.get('/foo').should be_nil
+      end
+
+      context 'when listing a prefix' do
+        it 'returns a hash of keys and their values' do
+          values = [
+            {'key' => '/foo/bar', 'value' => 'bar'},
+            {'key' => '/foo/baz', 'value' => 'baz'},
+          ]
+          stub_request(:get, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump(values))
+          client.get('/foo').should eql({'/foo/bar' => 'bar', '/foo/baz' => 'baz'})
+        end
+      end
+    end
+
+    describe '#set' do
+      before do
+        stub_request(:post, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({}))
+      end
+
+      it 'sends a POST request to set the value for a key' do
+        client.set('/foo', 'bar')
+        WebMock.should have_requested(:post, "#{base_uri}/keys/foo").with(body: 'value=bar')
+      end
+
+      it 'prepends a slash to keys when necessary' do
+        client.set('foo', 'bar')
+        WebMock.should have_requested(:post, "#{base_uri}/keys/foo").with(body: 'value=bar')
+      end
+
+      it 'parses the response and returns the previous value' do
+        stub_request(:post, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({'prevValue' => 'baz'}))
+        client.set('/foo', 'bar').should == 'baz'
+      end
+
+      it 'returns nil when there is no previous value' do
+        stub_request(:post, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({}))
+        client.set('/foo', 'bar').should be_nil
+      end
+
+      it 'sets a TTL when the :ttl option is given' do
+        client.set('/foo', 'bar', ttl: 3)
+        WebMock.should have_requested(:post, "#{base_uri}/keys/foo").with(body: 'value=bar&ttl=3')
+      end
+    end
+
+    describe '#update' do
+      before do
+        stub_request(:post, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({}))
+      end
+
+      it 'sends a POST request to set the value conditionally' do
+        client.update('/foo', 'bar', 'baz')
+        WebMock.should have_requested(:post, "#{base_uri}/keys/foo").with(body: 'value=bar&prevValue=baz')
+      end
+
+      it 'returns true when the key is successfully changed' do
+        stub_request(:post, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({}))
+        client.update('/foo', 'bar', 'baz').should be_true
+      end
+
+      it 'returns false when an error is returned' do
+        stub_request(:post, "#{base_uri}/keys/foo").to_return(status: 400, body: MultiJson.dump({}))
+        client.update('/foo', 'bar', 'baz').should be_false
+      end
+
+      it 'sets a TTL when the :ttl option is given' do
+        client.update('/foo', 'bar', 'baz', ttl: 3)
+        WebMock.should have_requested(:post, "#{base_uri}/keys/foo").with(body: 'value=bar&prevValue=baz&ttl=3')
+      end
+    end
+
+    describe '#delete' do
+      before do
+        stub_request(:delete, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({}))
+      end
+
+      it 'sends a DELETE request to remove a key' do
+        client.delete('/foo')
+        WebMock.should have_requested(:delete, "#{base_uri}/keys/foo")
+      end
+
+      it 'returns the previous value' do
+        stub_request(:delete, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({'prevValue' => 'bar'}))
+        client.delete('/foo').should == 'bar'
+      end
+
+      it 'returns nil when there is no previous value' do
+        stub_request(:delete, "#{base_uri}/keys/foo").to_return(status: 404, body: 'Not found')
+        client.delete('/foo').should be_nil
+      end
+    end
+
+    describe '#exists?' do
+      it 'returns true if the key has a value' do
+        stub_request(:get, "#{base_uri}/keys/foo").to_return(body: MultiJson.dump({'value' => 'bar'}))
+        client.exists?('/foo').should be_true
+      end
+
+      it 'returns false if the key does not exist' do
+        stub_request(:get, "#{base_uri}/keys/foo").to_return(status: 404, body: 'Not found')
+        client.exists?('/foo').should be_false
+      end
+    end
+
+    describe '#info' do
+      it 'returns the key, value, index, expiration and TTL for a key' do
+        body = MultiJson.dump({'action' => 'GET', 'key' => '/foo', 'value' => 'bar', 'index' => 31, 'expiration' => '2013-12-11T12:09:08.123+02:00', 'ttl' => 7})
+        stub_request(:get, "#{base_uri}/keys/foo").to_return(body: body)
+        info = client.info('/foo')
+        info[:key].should == '/foo'
+        info[:value].should == 'bar'
+        info[:index].should == 31
+        info[:expiration].to_f.should == (Time.utc(2013, 12, 11, 10, 9, 8) + 0.123).to_f
+        info[:ttl].should == 7
+      end
+
+      it 'returns the dir flag' do
+        body = MultiJson.dump({'action' => 'GET', 'key' => '/foo', 'dir' => true})
+        stub_request(:get, "#{base_uri}/keys/foo").to_return(body: body)
+        info = client.info('/foo')
+        info[:key].should == '/foo'
+        info[:dir].should be_true
+      end
+
+      it 'returns only the pieces of information that are returned' do
+        body = MultiJson.dump({'action' => 'GET', 'key' => '/foo', 'value' => 'bar', 'index' => 31})
+        stub_request(:get, "#{base_uri}/keys/foo").to_return(body: body)
+        info = client.info('/foo')
+        info[:key].should == '/foo'
+        info[:value].should == 'bar'
+        info[:index].should == 31
+      end
+
+      it 'returns nil when the key does not exist' do
+        stub_request(:get, "#{base_uri}/keys/foo").to_return(status: 404, body: 'Not found')
+        client.info('/foo').should be_nil
+      end
+
+      context 'when listing a prefix' do
+        it 'returns a hash of keys and their info' do
+          body = MultiJson.dump([
+            {'action' => 'GET', 'key' => '/foo/bar', 'value' => 'bar', 'index' => 31},
+            {'action' => 'GET', 'key' => '/foo/baz', 'value' => 'baz', 'index' => 55},
+          ])
+          stub_request(:get, "#{base_uri}/keys/foo").to_return(body: body)
+          info = client.info('/foo')
+          info['/foo/bar'][:key].should == '/foo/bar'
+          info['/foo/baz'][:key].should == '/foo/baz'
+          info['/foo/bar'][:value].should == 'bar'
+          info['/foo/baz'][:value].should == 'baz'
+          info['/foo/bar'][:index].should == 31
+          info['/foo/baz'][:index].should == 55
+        end
+      end
+    end
+
+    describe '#watch' do
+      it 'sends a GET request for a watch of a key prefix' do
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {}).to_return(body: MultiJson.dump({}))
+        client.watch('/foo') { }
+        WebMock.should have_requested(:get, "#{base_uri}/watch/foo").with(query: {})
+      end
+
+      it 'sends a GET request for a watch of a key prefix from a specified index' do
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {'index' => 3}).to_return(body: MultiJson.dump({}))
+        client.watch('/foo', index: 3) { }
+        WebMock.should have_requested(:get, "#{base_uri}/watch/foo").with(query: {'index' => 3})
+      end
+
+      it 'yields the value' do
+        body = MultiJson.dump({'value' => 'bar'})
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {}).to_return(body: body)
+        value = nil
+        client.watch('/foo') do |v|
+          value = v
+        end
+        value.should == 'bar'
+      end
+
+      it 'yields the changed key' do
+        body = MultiJson.dump({'key' => '/foo/bar', 'value' => 'bar'})
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {}).to_return(body: body)
+        key = nil
+        client.watch('/foo') do |_, k|
+          key = k
+        end
+        key.should == '/foo/bar'
+      end
+
+      it 'yields info about the key, when it is a new key' do
+        body = MultiJson.dump({'action' => 'SET', 'key' => '/foo/bar', 'value' => 'bar', 'index' => 3, 'newKey' => true})
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {}).to_return(body: body)
+        info = nil
+        client.watch('/foo') do |_, _, i|
+          info = i
+        end
+        info[:action].should == :set
+        info[:key].should == '/foo/bar'
+        info[:value].should == 'bar'
+        info[:index].should == 3
+        info[:new_key].should be_true
+      end
+
+      it 'yields info about the key, when the key was changed' do
+        body = MultiJson.dump({'action' => 'SET', 'key' => '/foo/bar', 'value' => 'bar', 'prevValue' => 'baz', 'index' => 3})
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {}).to_return(body: body)
+        info = nil
+        client.watch('/foo') do |_, _, i|
+          info = i
+        end
+        info[:action].should == :set
+        info[:key].should == '/foo/bar'
+        info[:value].should == 'bar'
+        info[:index].should == 3
+        info[:previous_value].should == 'baz'
+      end
+
+      it 'yields info about the key, when the key has a TTL' do
+        body = MultiJson.dump({'action' => 'SET', 'key' => '/foo/bar', 'value' => 'bar', 'index' => 3, 'expiration' => '2013-12-11T12:09:08.123+02:00', 'ttl' => 7})
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {}).to_return(body: body)
+        info = nil
+        client.watch('/foo') do |_, _, i|
+          info = i
+        end
+        info[:action].should == :set
+        info[:key].should == '/foo/bar'
+        info[:value].should == 'bar'
+        info[:index].should == 3
+        info[:expiration].to_f.should == (Time.utc(2013, 12, 11, 10, 9, 8) + 0.123).to_f
+        info[:ttl].should == 7
+      end
+
+      it 'returns the return value of the block' do
+        body = MultiJson.dump({'action' => 'SET', 'key' => '/foo/bar', 'value' => 'bar', 'index' => 3, 'expiration' => '2013-12-11T12:09:08.123+02:00', 'ttl' => 7})
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {}).to_return(body: body)
+        return_value = client.watch('/foo') do |_, k, _|
+          k
+        end
+        return_value.should == '/foo/bar'
+      end
+    end
+
+    describe '#observe' do
+      it 'watches the specified key prefix' do
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {}).to_return(body: MultiJson.dump({}))
+        barrier = Queue.new
+        observer = client.observe('/foo') do
+          barrier << :ping
+          observer.cancel
+          observer.join
+        end
+        barrier.pop
+        WebMock.should have_requested(:get, "#{base_uri}/watch/foo").with(query: {})
+      end
+
+      it 're-watches the prefix with the last seen index immediately' do
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {}).to_return(body: MultiJson.dump({'index' => 3}))
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {'index' => 3}).to_return(body: MultiJson.dump({'index' => 4}))
+        barrier = Queue.new
+        observer = client.observe('/foo') do |_, _, info|
+          if info[:index] == 4
+            barrier << :ping
+            observer.cancel
+            observer.join
+          end
+        end
+        barrier.pop
+        WebMock.should have_requested(:get, "#{base_uri}/watch/foo").with(query: {})
+        WebMock.should have_requested(:get, "#{base_uri}/watch/foo").with(query: {'index' => 3})
+      end
+
+      it 'yields the value, key and info to the block given' do
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {}).to_return(body: MultiJson.dump({'action' => 'SET', 'key' => '/foo/bar', 'value' => 'bar', 'index' => 3, 'newKey' => true}))
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {'index' => 3}).to_return(body: MultiJson.dump({'action' => 'DELETE', 'key' => '/foo/baz', 'value' => 'foo', 'index' => 4}))
+        stub_request(:get, "#{base_uri}/watch/foo").with(query: {'index' => 4}).to_return(body: MultiJson.dump({'action' => 'SET', 'key' => '/foo/bar', 'value' => 'hello', 'index' => 5}))
+        barrier = Queue.new
+        values = []
+        keys = []
+        actions = []
+        new_keys = []
+        observer = client.observe('/foo') do |value, key, info|
+          values << value
+          keys << key
+          actions << info[:action]
+          new_keys << info[:new_key]
+          if info[:index] == 5
+            barrier << :ping
+            observer.cancel
+            observer.join
+          end
+        end
+        barrier.pop
+        values.should == %w[bar foo hello]
+        keys.should == %w[/foo/bar /foo/baz /foo/bar]
+        actions.should == [:set, :delete, :set]
+        new_keys.should == [true, nil, nil]
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+require 'bundler/setup'
+require 'etcd'
+require 'webmock/rspec'

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: etcd-rb
+version: !ruby/object:Gem::Version
+  version: 1.0.0.pre0
+  prerelease: 6
+platform: ruby
+authors:
+- Theo Hultberg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-04 00:00:00.000000000 Z
+dependencies: []
+description: ''
+email:
+- theo@iconara.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/etcd/client.rb
+- lib/etcd/version.rb
+- lib/etcd.rb
+- README.md
+- spec/etcd/client_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/iconara/etcd-rb
+licenses:
+- Apache License 2.0
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: ''
+test_files:
+- spec/etcd/client_spec.rb
+- spec/spec_helper.rb
+has_rdoc: