etcd-rb 1.0.0 → 1.1.0

data/spec/etcd/cluster_spec.rb

@@ -15,35 +15,24 @@ module Etcd
         it "returns parsed data" do
           with_stubbed_status(cluster_uri) do
             res = Etcd::Cluster.cluster_status(cluster_uri)
-            res[0][:name].should == "node1"
+            res[0][:name].should eq("node1")
           end
         end
       end
 
-      describe '#parse_cluster_status' do
-        it "works with correct parsed json" do
-          res = Etcd::Cluster.parse_cluster_status(status_data)
-          res[0].should == {
-            :name => "node1",
-            :raft => "http://127.0.0.1:7001",
-            :etcd => "http://127.0.0.1:4001",
-          }
-        end
-      end
-
       describe '#nodes_from_uri' do
         it "returns node instances created from uri" do
           with_stubbed_status(cluster_uri) do
             nodes = Etcd::Cluster.nodes_from_uri(cluster_uri)
-            nodes.size.should == 3
-            nodes.first.class.should == Etcd::Node
+            nodes.size.should eq(3)
+            nodes.first.class.should eq(Etcd::Node)
           end
         end
 
         it "but those instances have no real status yet" do
           with_stubbed_status(cluster_uri) do
             nodes = Etcd::Cluster.nodes_from_uri(cluster_uri)
-            nodes.size.should == 3
+            nodes.size.should eq(3)
             nodes.first.status == :unknown
           end
         end
@@ -55,9 +44,10 @@ module Etcd
             with_stubbed_status(cluster_uri) do
               with_stubbed_leaders(healthy_cluster_config) do
                 cluster = Etcd::Cluster.init_from_uris(cluster_uri)
+                puts "nodes: #{cluster}"
                 nodes = cluster.nodes
-                nodes.size.should == 3
-                nodes.map{|x| x.status}.uniq.should == [:running]
+                nodes.size.should eq(3)
+                nodes.map{|x| x.status}.uniq.should eq([:running])
               end
             end
           end
@@ -67,7 +57,7 @@ module Etcd
               with_stubbed_leaders(healthy_cluster_config) do
                 cluster = Etcd::Cluster.init_from_uris(cluster_uri)
                 leader  = cluster.leader
-                leader.etcd.should == cluster_uri
+                expect(leader.client_urls.first).to eq(cluster_uri)
               end
             end
           end
@@ -80,8 +70,8 @@ module Etcd
               with_stubbed_leaders(one_down_cluster_config) do
                 cluster = Etcd::Cluster.init_from_uris(cluster_uri)
                 nodes = cluster.nodes
-                nodes.size.should == 3
-                nodes.map{|x| x.status}.uniq.should == [:running, :down]
+                nodes.size.should eq(3)
+                nodes.map{|x| x.status}.uniq.should eq([:running, :down])
               end
             end
           end
@@ -93,7 +83,7 @@ module Etcd
       describe '#new' do
         it "will not request any info on initialization" do
           cluster = Etcd::Cluster.new(cluster_uri)
-          WebMock.should_not have_requested(:get, "http://127.0.0.1:4001/v1/keys/_etcd/machines/")
+          WebMock.should_not have_requested(:get, "http://127.0.0.1:4001/v2/members/")
         end
       end
 
@@ -103,7 +93,7 @@ module Etcd
             with_stubbed_leaders(healthy_cluster_config) do
               cluster = Etcd::Cluster.new(cluster_uri)
               nodes   = cluster.nodes
-              nodes.size.should == 3
+              nodes.size.should eq(3)
             end
           end
         end
@@ -113,13 +103,13 @@ module Etcd
             with_stubbed_leaders(healthy_cluster_config) do
               cluster = Etcd::Cluster.new(cluster_uri)
               nodes   = cluster.nodes
-              nodes.map{|x| x.status}.uniq.should == [:running]
+              nodes.map{|x| x.status}.uniq.should eq([:running])
               with_stubbed_leaders(one_down_cluster_config) do
                 nodes   = cluster.nodes
                 nodes.map{|x| x.status}.uniq.should_not == [:running, :down]
                 # now update for real
                 nodes   = cluster.update_status
-                nodes.map{|x| x.status}.uniq.should == [:running, :down]
+                nodes.map{|x| x.status}.uniq.should eq([:running, :down])
               end
             end
           end
@@ -133,11 +123,11 @@ module Etcd
             with_stubbed_leaders(healthy_cluster_config) do
               cluster = Etcd::Cluster.new(cluster_uri)
               nodes   = cluster.update_status
-              nodes.size.should == 3
-              nodes.map{|x| x.status}.uniq.should == [:running]
+              nodes.size.should eq(3)
+              nodes.map{|x| x.status}.uniq.should eq([:running])
               with_stubbed_leaders(one_down_cluster_config) do
                 nodes   = cluster.update_status
-                nodes.map{|x| x.status}.uniq.should == [:running, :down]
+                nodes.map{|x| x.status}.uniq.should eq([:running, :down])
               end
             end
           end
@@ -151,8 +141,8 @@ module Etcd
             with_stubbed_leaders(healthy_cluster_config) do
               cluster = Etcd::Cluster.new(cluster_uri)
               leader = cluster.leader
-              leader.etcd.should == cluster_uri
-              leader.is_leader.should eq(true)
+              expect(leader.client_urls.first).to eq(cluster_uri)
+              expect(leader.is_leader).to eq(true)
             end
           end
         end
@@ -161,10 +151,10 @@ module Etcd
           with_stubbed_status(cluster_uri) do
             with_stubbed_leaders(healthy_cluster_config) do
               cluster = Etcd::Cluster.new(cluster_uri)
-              cluster.leader.etcd.should == cluster_uri
+              expect(cluster.leader.client_urls.first).to eq(cluster_uri)
               with_stubbed_leaders(healthy_cluster_changed_leader_config) do
-                nodes   = cluster.update_status
-                cluster.leader.etcd.should == "http://127.0.0.1:4002"
+                nodes = cluster.update_status
+                expect(cluster.leader.client_urls.first).to eq("http://127.0.0.1:4002")
               end
             end
           end

data/spec/etcd/node_spec.rb

@@ -1,23 +1,35 @@
 # encoding: utf-8
 require 'spec_helper'
 
-
 module Etcd
   describe Node do
 
+    let :node_data do
+      [
+       {"id" => "14306b09b8d69fc4","name" => "node1","peerURLs"=> ["http://127.0.0.1:7001"],"clientURLs" => ["http://127.0.0.1:4001"]},
+       {"id" => "d2356cd527a56a4","name" => "node2","peerURLs" => ["http://127.0.0.1:7002"],"clientURLs" => ["http://127.0.0.1:4002"]}
+      ]
+    end
+
     def default_node(opts = {})
-      args = {:name => "node1", :etcd => "http://example.com:4001", :raft => "http://example.com:7001"}
-      Etcd::Node.new(args.merge(opts))
+      data = Etcd::Node.parse_node_data(node_data[0])
+      Etcd::Node.new(data.merge(opts))
     end
 
     describe '#initialize' do
       it "works with all required parameters" do
-        default_node({}).should_not == nil
+        default_node({}).should_not be_nil
+      end
+
+      it "raises if :client_urls is missing" do
+        expect {
+          default_node({:client_urls => nil})
+        }.to raise_error(ArgumentError)
       end
 
-      it "raises if :etcd url is missing" do
+      it "raises if :id is missing" do
         expect {
-          default_node({:etcd => nil})
+          default_node({:id => nil})
         }.to raise_error(ArgumentError)
       end
     end
@@ -25,31 +37,31 @@ module Etcd
     describe '#update_status' do
       it "sets status :running if alive" do
         node = default_node
-        stub_request(:get, node.leader_uri).to_return(body: node.raft)
+        stub_request(:get, node.leader_uri).to_return(body: node.to_json)
         node.update_status
-        node.status.should == :running
+        node.status.should eq(:running)
       end
 
       it "sets status :down if down" do
         node = default_node
         stub_request(:get, node.leader_uri).to_timeout
         node.update_status
-        node.status.should == :down
+        node.status.should eq(:down)
       end
 
       it "marks leader-flag if leader" do
         node = default_node
-        stub_request(:get, node.leader_uri).to_return(body: node.raft)
+        stub_request(:get, node.leader_uri).to_return(body: node.to_json)
         node.update_status
         node.is_leader.should eq(true)
       end
 
       it "marks leader-flag as :false if leader looses leadership" do
         node = default_node
-        stub_request(:get, node.leader_uri).to_return(body: node.raft)
+        stub_request(:get, node.leader_uri).to_return(body: node.to_json)
         node.update_status
         node.is_leader.should eq(true)
-        stub_request(:get, node.leader_uri).to_return(body: "bla")
+        stub_request(:get, node.leader_uri).to_return(body: node_data[1].to_json)
         node.update_status
         node.is_leader.should eq(false)
       end

data/spec/etcd/observer_spec.rb

@@ -7,7 +7,7 @@ module Etcd
     include ClientHelper
 
     def base_uri
-      "http://127.0.0.1:4001/v1"
+      "http://127.0.0.1:4001/v2"
     end
 
     let :client do
@@ -16,95 +16,95 @@ module Etcd
 
     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({}))
+        stub_request(:get, "#{base_uri}/keys/foo").with(query: {wait: 'true'}).to_return(body: MultiJson.dump({}))
         client.watch('/foo') { }
-        WebMock.should have_requested(:get, "#{base_uri}/watch/foo").with(query: {})
+        WebMock.should have_requested(:get, "#{base_uri}/keys/foo").with(query: {wait: 'true'})
       end
 
       it 'sends a GET request for a watch of a key prefix from a specified index' do
-        stub_request(:post, "#{base_uri}/watch/foo").with(query: {'index' => 3}).to_return(body: MultiJson.dump({}))
+        stub_request(:get, "#{base_uri}/keys/foo").with(query: {'wait' => 'true', 'index' => 3}).to_return(body: MultiJson.dump({}))
         client.watch('/foo', index: 3) { }
-        WebMock.should have_requested(:post, "#{base_uri}/watch/foo").with(query: {'index' => 3})
+        WebMock.should have_requested(:get, "#{base_uri}/keys/foo").with(query: {'wait' => 'true', '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)
+        body = MultiJson.dump({'node' => {'value' => 'bar'}})
+        stub_request(:get, "#{base_uri}/keys/foo").with(query: {'wait' => 'true'}).to_return(body: body)
         value = nil
         client.watch('/foo') do |v|
           value = v
         end
-        value.should == 'bar'
+        value.should eq('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)
+        body = MultiJson.dump({'node' => {'key' => '/foo/bar', 'value' => 'bar'}})
+        stub_request(:get, "#{base_uri}/keys/foo").with(query: {'wait' => 'true'}).to_return(body: body)
         key = nil
         client.watch('/foo') do |_, k|
           key = k
         end
-        key.should == '/foo/bar'
+        key.should eq('/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)
+        body = MultiJson.dump({'action' => 'SET', 'node' => {'key' => '/foo/bar', 'value' => 'bar', 'index' => 3}})
+        stub_request(:get, "#{base_uri}/keys/foo").with(query: {'wait' => 'true'}).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[:action].should eq(:set)
+        info[:key].should eq('/foo/bar')
+        info[:value].should eq('bar')
+        info[:index].should eq(3)
         info[:new_key].should eq(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)
+        body = MultiJson.dump({'action' => 'set', 'node' => {'key' => '/foo/bar', 'value' => 'bar', 'index' => 3}, 'prevNode' => {'value' => 'baz'}})
+        stub_request(:get, "#{base_uri}/keys/foo").with(query: {'wait' => 'true'}).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'
+        info[:action].should eq(:set)
+        info[:key].should eq('/foo/bar')
+        info[:value].should eq('bar')
+        info[:index].should eq(3)
+        info[:previous_value].should eq('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)
+        body = MultiJson.dump({'action' => 'set', 'node' => {'key' => '/foo/bar', 'value' => 'bar', 'index' => 3, 'expiration' => '2013-12-11T12:09:08.123+02:00', 'ttl' => 7}})
+        stub_request(:get, "#{base_uri}/keys/foo").with(query: {'wait' => 'true'}).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[:action].should eq(:set)
+        info[:key].should eq('/foo/bar')
+        info[:value].should eq('bar')
+        info[:index].should eq(3)
         # rounding because of ruby 2.0 time parsing bug @see https://gist.github.com/mindreframer/6746829
-        info[:expiration].to_f.round.should == (Time.utc(2013, 12, 11, 10, 9, 8) + 0.123).to_f.round
-        info[:ttl].should == 7
+        info[:expiration].to_f.round.should eq((Time.utc(2013, 12, 11, 10, 9, 8) + 0.123).to_f.round)
+        info[:ttl].should eq(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)
+        body = MultiJson.dump({'action' => 'set', 'node' => {'key' => '/foo/bar', 'value' => 'bar', 'index' => 3, 'expiration' => '2013-12-11T12:09:08.123+02:00', 'ttl' => 7}})
+        stub_request(:get, "#{base_uri}/keys/foo").with(query: {'wait' => 'true'}).to_return(body: body)
         return_value = client.watch('/foo') do |_, k, _|
           k
         end
-        return_value.should == '/foo/bar'
+        return_value.should eq('/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({}))
+        stub_request(:get, "#{base_uri}/keys/foo").with(query: {'wait' => 'true'}).to_return(body: MultiJson.dump({'node' => {}}))
         barrier = Queue.new
         observer = client.observe('/foo') do
           barrier << :ping
@@ -112,12 +112,12 @@ module Etcd
           observer.join
         end
         barrier.pop
-        WebMock.should have_requested(:get, "#{base_uri}/watch/foo").with(query: {})
+        WebMock.should have_requested(:get, "#{base_uri}/keys/foo").with(query: {'wait' => 'true'})
       end
 
       it 're-watches the prefix with the (last seen index + 1)  immediately' do
-        stub_request(:get, "#{base_uri}/watch/foo").with(query: {}).to_return(body: MultiJson.dump({'index' => 3}))
-        stub_request(:post, "#{base_uri}/watch/foo").with(query: {'index' => 4}).to_return(body: MultiJson.dump({'index' => 4}))
+        stub_request(:get, "#{base_uri}/keys/foo").with(query: {'wait' => 'true'}).to_return(body: MultiJson.dump({'node' => {'index' => 3}}))
+        stub_request(:get, "#{base_uri}/keys/foo").with(query: {'wait' => 'true', 'index' => 4}).to_return(body: MultiJson.dump({'node' => {'index' => 4}}))
         barrier = Queue.new
         observer = client.observe('/foo') do |_, _, info|
           if info[:index] == 4
@@ -127,14 +127,14 @@ module Etcd
           end
         end
         barrier.pop
-        WebMock.should have_requested(:get, "#{base_uri}/watch/foo").with(query: {})
-        WebMock.should have_requested(:post, "#{base_uri}/watch/foo").with(query: {'index' => 4})
+        WebMock.should have_requested(:get, "#{base_uri}/keys/foo").with(query: {'wait' => 'true'})
+        WebMock.should have_requested(:get, "#{base_uri}/keys/foo").with(query: {'wait' => 'true', 'index' => 4})
       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(:post, "#{base_uri}/watch/foo").with(query: {'index' => 4}).to_return(body: MultiJson.dump({'action' => 'DELETE', 'key' => '/foo/baz', 'value' => 'foo', 'index' => 4}))
-        stub_request(:post, "#{base_uri}/watch/foo").with(query: {'index' => 5}).to_return(body: MultiJson.dump({'action' => 'SET', 'key' => '/foo/bar', 'value' => 'hello', 'index' => 5}))
+        stub_request(:get, "#{base_uri}/keys/foo").with(query: {'wait' => 'true'}).to_return(body: MultiJson.dump({'action' => 'set', 'node' => {'key' => '/foo/bar', 'value' => 'bar', 'index' => 3}}))
+        stub_request(:get, "#{base_uri}/keys/foo").with(query: {'wait' => 'true', 'index' => 4}).to_return(body: MultiJson.dump({'action' => 'delete', 'node' => {'key' => '/foo/baz', 'value' => 'foo', 'index' => 4}, 'prevNode' => {}}))
+        stub_request(:get, "#{base_uri}/keys/foo").with(query: {'wait' => 'true', 'index' => 5}).to_return(body: MultiJson.dump({'action' => 'set', 'node' => {'key' => '/foo/bar', 'value' => 'hello', 'index' => 5}, 'prevNode' => {}}))
         barrier = Queue.new
         values   = []
         keys     = []
@@ -152,10 +152,10 @@ module Etcd
           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]
+        values.should   eq(%w[bar foo hello])
+        keys.should     eq(%w[/foo/bar /foo/baz /foo/bar])
+        actions.should  eq([:set, :delete, :set])
+        new_keys.should eq([true, false, false])
       end
     end
 

data/spec/integration/etcd_spec.rb

@@ -6,10 +6,6 @@ require 'open-uri'
 
 describe 'With real server an etcd client' do
 
-  let :client do
-    Etcd::Client.test_client
-  end
-
   let :prefix do
     "/etcd-rb/#{rand(234234)}"
   end
@@ -23,8 +19,18 @@ describe 'With real server an etcd client' do
     WebMock.allow_net_connect!
   end
 
-  before do
+  before(:all) do
+    ClusterController.stop_cluster
     ClusterController.start_cluster
+    sleep 2 # wait a little for the cluster to come up
+  end
+
+  after(:all) do
+    ClusterController.stop_cluster
+  end
+
+  let :client do
+    Etcd::Client.test_client
   end
 
   before do
@@ -37,7 +43,7 @@ describe 'With real server an etcd client' do
 
   it 'sets and gets the value for a key' do
     client.set(key, 'foo')
-    client.get(key).should == 'foo'
+    client.get(key).should eq('foo')
   end
 
   it 'sets a key with a TTL' do
@@ -49,8 +55,8 @@ describe 'With real server an etcd client' do
   it 'watches for changes to a key' do
     Thread.start { sleep(0.1); client.set(key, 'baz') }
     new_value, info = *client.watch(key) { |v, k, info|  [v, info]  }
-    new_value.should == 'baz'
-    info[:new_key].should == true
+    new_value.should eq('baz')
+    info[:new_key].should eq(true)
   end
 
   it 'conditionally sets the value for a key' do
@@ -59,11 +65,12 @@ describe 'With real server an etcd client' do
     client.update(key, 'qux', 'bar').should eq(true)
   end
 
-
+  # FIXME: this test does not pass consistently. There seem to issues
+  # with the leader re-election handling (causing Errno::ECONNREFUSED)
   it "has heartbeat, that resets observed watches" do
-    ClusterController.start_cluster
-    client = Etcd::Client.test_client(:heartbeat_freq => 0.2)
-    client.cluster.nodes.map(&:status).uniq.should == [:running]
+    client = Etcd::Client.test_client(:heartbeat_freq => 0.1)
+    puts client.cluster.nodes.map(&:inspect)
+    client.cluster.nodes.map(&:status).uniq.should eq([:running])
     changes = Queue.new
 
     client.observe('/foo') do |v,k,info|
@@ -71,7 +78,7 @@ describe 'With real server an etcd client' do
       changes << info
     end
 
-    changes.size.should == 0
+    changes.size.should eq(0)
 
     ### simulate second console
     a = Thread.new do
@@ -83,9 +90,15 @@ describe 'With real server an etcd client' do
       sleep 0.4
       puts "2.nd try"
       client.set("/foo", "barss")
+      sleep 0.4
     end
 
-    sleep 1.5
-    changes.size.should == 2
+    a.join
+    changes.size.should eq(2)
+
+    # restore cluster
+    ClusterController.stop_cluster
+    ClusterController.start_cluster
+    sleep 2
   end
-end
+end