dynport_tools 0.2.19 → 0.2.20

data/spec/dynport_tools/features_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe DynportTools::Features do
+  let(:redis) { Redis.new }
+  
+  before(:each) do
+    DynportTools::Features.features = nil
+    keys = redis.keys("features*")
+    redis.multi do
+      keys.each do |key|
+        redis.del(key)
+      end
+    end
+    DynportTools::Features.redis = redis
+  end
+  
+  describe "defining features" do
+    it "adds the features to an array" do
+      DynportTools::Features.feature :solr
+      DynportTools::Features.feature :sphinx
+      DynportTools::Features.features.should == [:solr, :sphinx]
+    end
+    
+    it "adds the *_enabled_for? method" do
+      DynportTools::Features.feature :solr
+      DynportTools::Features.should respond_to(:solr_enabled_for?)
+    end
+    
+    it "returns true when user included in users set" do
+      user = double("user", :id => 2)
+      DynportTools::Features.feature :solr
+      DynportTools::Features.add_user(:solr, user)
+      DynportTools::Features.solr_enabled_for?(user).should == true
+    end
+    
+    it "returns false when user not included in user set" do
+      user = double("user", :id => 2)
+      DynportTools::Features.feature :solr
+      DynportTools::Features.solr_enabled_for?(user).should == false
+    end
+    
+    it "returns false when user is nil" do
+      DynportTools::Features.feature :solr
+      DynportTools::Features.solr_enabled_for?(nil).should == false
+    end
+    
+    it "executes the block given when enabled" do
+      user = double("user", :id => 2)
+      DynportTools::Features.feature :solr
+      DynportTools::Features.add_user(:solr, user)
+      called = false
+      DynportTools::Features.solr_enabled_for?(user) do
+        called = true
+      end.should == true
+      called.should == true
+    end
+    
+    it "does not execute the block given when not enabled" do
+      DynportTools::Features.feature :solr
+      called = false
+      DynportTools::Features.solr_enabled_for?(nil) do
+        called = true
+      end.should == false
+      called.should == false
+    end
+  end
+  
+  it "allows setting a redis instance" do
+    r = double("my r")
+    DynportTools::Features.redis = r
+    DynportTools::Features.redis.should == r
+  end
+  
+  describe "add_user" do
+    before(:each) do
+      DynportTools::Features.feature :solr
+    end
+    
+    it "raises an error when feature not defined" do
+      lambda { 
+        DynportTools::Features.add_user(:some_other, double("user", :id => 2))
+      }.should raise_error
+    end
+    
+    it "adds the user id to the specific group" do
+      DynportTools::Features.add_user(:solr, double("user", :id => 2))
+      DynportTools::Features.add_user(:solr, double("user", :id => 2))
+      DynportTools::Features.add_user(:solr, double("user", :id => 4))
+      redis.smembers("features/solr/users").should == %w(2 4)
+    end
+  end
+  
+  describe "remove_user" do
+    it "correctly removes users" do
+      DynportTools::Features.feature :solr
+      DynportTools::Features.add_user(:solr, double("user", :id => 2))
+      redis.smembers("features/solr/users").should == %w(2)
+      DynportTools::Features.remove_user(:solr, double("user", :id => 2))
+      redis.smembers("features/solr/users").should == %w()
+    end
+  end
+end

data/spec/dynport_tools/services_spec.rb

@@ -0,0 +1,303 @@
+$:<<File.expand_path("../../../", __FILE__)
+require "dynport_tools"
+require "dynport_tools/services"
+
+describe "Services" do
+  let(:services) { DynportTools::Services.new }
+  before(:each) do
+    services.stub(:system_call).and_raise("stub me")
+  end
+  
+  it "can be initialized" do
+    DynportTools::Services.new.should be_kind_of(DynportTools::Services)
+  end
+  
+  describe "solr_root" do
+    it "allows setting the solr root" do
+      services.solr_data_root = "/tmp/solr_path"
+      services.solr_data_root.should == "/tmp/solr_path"
+    end
+    
+    it "returns /opt/solr by default" do
+      services.solr_data_root.should == "/opt/solr"
+    end
+  end
+  
+  describe "solr" do
+    let(:tmp_path) { "/tmp/solr_#{Time.now.to_f.to_s.gsub(".", "")}" }
+    let(:solr_xml) { "#{tmp_path}/solr.xml"}
+    
+    after do(:each)
+      FileUtils.rm_rf(tmp_path)
+    end
+    
+    describe "#solr_bootstrapped?" do
+      before(:each) do
+        services.solr_data_root = tmp_path
+      end
+      
+      it "returns false by default" do
+        services.should_not be_solr_bootstrapped
+      end
+      
+      it "returns true when solr.xml exists" do
+        FileUtils.mkdir_p(tmp_path)
+        FileUtils.touch(solr_xml)
+        services.should be_solr_bootstrapped
+      end
+    end
+    
+    describe "bootstrap_solr" do
+      before(:each) do
+        services.solr_data_root = tmp_path
+      end
+      
+      it "raises an error when dir not exists" do
+        lambda {
+          services.bootstrap_solr
+        }.should raise_error("please create #{tmp_path} first")
+      end
+      
+      it "creates a new solr.xml when not exists" do
+        FileUtils.mkdir_p(tmp_path)
+        services.bootstrap_solr
+        File.should be_exists(solr_xml)
+      end
+      
+      it "sets the correct content" do
+        FileUtils.mkdir_p(tmp_path)
+        services.bootstrap_solr
+        expected = %(
+          <?xml version="1.0" encoding="UTF-8" ?>
+          <solr sharedLib="lib" persistent="true">
+            <cores adminPath="/admin/cores">
+            </cores>
+          </solr>
+        ).gsub(/^\s+/, "")
+        File.read(solr_xml).should == expected
+      end
+      
+      it "raises an error when solr.xml already exists" do
+        FileUtils.mkdir_p(tmp_path)
+        FileUtils.touch(solr_xml)
+        lambda {
+          services.bootstrap_solr
+        }.should raise_error("#{solr_xml} already exists")
+      end
+    end
+    
+    describe "#solr_running?" do
+      it "calls head with the correct url" do
+        services.should_receive(:head).with("http://localhost:8983/solr/").and_return 200
+        services.should be_solr_running
+      end
+    
+      it "returns false when head != 200" do
+        services.should_receive(:head).with("http://localhost:8983/solr/").and_return 404
+        services.should_not be_solr_running
+      end
+    
+      it "uses a custom solr_url when set" do
+        services.solr_url = "http://some.host:8080/solr/"
+        services.should_receive(:head).with("http://some.host:8080/solr/").and_return 200
+        services.should be_solr_running
+      end
+    end
+    
+    describe "#solr_core_exists?" do
+      it "calls head with the correct url" do
+        services.solr_url = "http://some.host:8080/solr/"
+        services.should_receive(:head).with("http://some.host:8080/solr/custom_core_name/admin/").and_return 200
+        services.should be_solr_core_exists("custom_core_name")
+      end
+      
+      it "returns false when status code != 200" do
+        services.solr_url = "http://some.host:8080/solr/"
+        services.should_receive(:head).with("http://some.host:8080/solr/custom_core_name_2/admin/").and_return 404
+        services.should_not be_solr_core_exists("custom_core_name_2")
+      end
+    end
+    
+    describe "#create_solr_core" do
+      before(:each) do
+        services.solr_url = "http://some.host:8080/solr/"
+        services.solr_instance_path = "/path/to/solr/instance"
+        services.solr_data_root = "/solr/data"
+      end
+      
+      it "calls post with the correct url" do
+        url = "http://some.host:8080/solr/admin/cores?action=CREATE&name=new_core_name&instanceDir=/path/to/solr/instance&dataDir=/solr/data/new_core_name"
+        services.should_receive(:post).with(url)
+        services.create_solr_core("new_core_name")
+      end
+      
+      it "raises an error when solr_instance_path is not set" do
+        services.should_not_receive(:post)
+        services.solr_instance_path = nil
+        lambda {
+          services.create_solr_core("new_core_name")
+        }.should raise_error("please set solr_instance_path first!")
+      end
+    end
+    
+    describe "#unload_solr_core" do
+      it "calls the correct post method (haha, post)" do
+        services.solr_url = "http://some.host:8080/solr/"
+        url = "http://some.host:8080/solr/admin/cores?action=UNLOAD&core=core_to_unload"
+        services.should_receive(:post).with(url)
+        services.unload_solr_core("core_to_unload")
+      end
+    end
+  end
+  
+  describe "redis" do
+    before(:each) do
+      services.redis_path_prefix = "/tmp/path/to/redis"
+    end
+    
+    describe "#redis_path_prefix" do
+      it "raises an error when not set" do
+        services.redis_path_prefix = nil
+        lambda {
+          services.redis_path_prefix
+        }.should raise_error("redis_path_prefix not set!")
+      end
+    end
+    
+    it "returns the correct redis_socket_path when redis_path_prefix is set" do
+      services.redis_socket_path.should == "/tmp/path/to/redis.socket"
+    end
+    
+    it "returns the correct redis_config_path when redis_path_prefix is set" do
+      services.redis_config_path.should == "/tmp/path/to/redis.conf"
+    end
+    
+    describe "#redis_running?" do
+      before(:each) do
+        services.unstub(:system_call)
+        services.stub(:redis_socket_path).and_return("/path/to/redis.socket")
+      end
+    
+      it "executes the correct command" do
+        services.should_receive(:system_call).with(%(echo "info" | redis-cli -s /path/to/redis.socket 2> /dev/null | grep uptime_in_seconds)).and_return "uptime_in_seconds:1787353"
+        services.should be_redis_running
+      end
+    
+      it "returns false when system_call returns a blank string" do
+        services.should_receive(:system_call).with(%(echo "info" | redis-cli -s /path/to/redis.socket 2> /dev/null | grep uptime_in_seconds)).and_return ""
+        services.should_not be_redis_running
+      end
+    end
+  
+    describe "#start_redis" do
+      before(:each) do
+        services.stub!(:write_redis_config)
+        services.stub!(:system_call)
+      end
+    
+      it "calls write_redis_config" do
+        services.should_receive(:write_redis_config)
+        services.start_redis
+      end
+    
+      it "starts redis with the correct command" do
+        services.redis_path_prefix = "/path/to/redis"
+        services.should_receive(:system_call).with("redis-server /path/to/redis.conf")
+        services.start_redis
+      end
+    end
+  
+    describe "#write_redis_config" do
+      it "writes redis_config to the correct path" do
+        services.stub!(:redis_config).and_return("some config")
+        services.redis_path_prefix = "/path/to/redis"
+        file = double("file")
+        File.should_receive(:open).with("/path/to/redis.conf", "w").and_yield(file)
+        file.should_receive(:puts).with("some config")
+        services.write_redis_config
+      end
+    end
+    
+    describe "#redis_config_hash" do
+      it "returns the default hash by default" do
+        services.redis_path_prefix = "/path/to/redis"
+        services.redis_config_hash.should == {
+          :unixsocket => "/path/to/redis.socket",
+          :logfile => "/path/to/redis.log",
+          :daemonize => "yes",
+          :port => 0
+        }
+      end
+      
+      it "merges the custom set redis_config_path" do
+        services.redis_path_prefix = "/path/to/redis"
+        services.redis_config_hash = { :port => 1234 }
+        services.redis_config_hash.should == {
+          :unixsocket => "/path/to/redis.socket",
+          :port => 1234,
+          :logfile => "/path/to/redis.log",
+          :daemonize => "yes"
+        }
+      end
+    end
+  
+    describe "#redis_config" do
+      it "returns a string" do
+        services.redis_config.should be_kind_of(String)
+      end
+    
+      it "returns the correct string" do
+        services.stub(:redis_config_hash).and_return(
+          :port => 0,
+          :unixsocket => "/path/to/socket"
+        )
+        services.redis_config.split("\n").sort.should == ["port 0", "unixsocket /path/to/socket"].sort
+      end
+      
+      it "does not include empty values" do
+        services.stub(:redis_config_hash).and_return(
+          :port => nil,
+          :unixsocket => "/path/to/socket"
+        )
+        services.redis_config.should == "unixsocket /path/to/socket"
+      end
+    end
+  end
+  
+  it "forwards the system call" do
+    services.unstub(:system_call)
+    services.stub(:puts)
+    Kernel.should_receive(:`).with("ls -l").and_return("the result")
+    services.system_call("ls -l").should == "the result"
+  end
+  
+  describe "http methods" do
+    let(:url) { "http://www.some.host:1234/path" }
+    describe "#head" do
+      before(:each) do
+        services.unstub(:system_call)
+      end
+    
+      it "executes the correct system call" do
+        services.should_receive(:system_call).with(%(curl -s -I "#{url}" | head -n 1)).and_return("HTTP/1.1 200 OK")
+        services.head(url).should == 200
+      end
+    
+      it "returns nil when result is empty" do
+        services.stub(:system_call).and_return("")
+        services.head("/some/path").should be_nil
+      end
+    end
+    
+    describe "#post" do
+      before(:each) do
+        services.unstub(:system_call)
+      end
+      
+      it "executes the correct system call" do
+        services.should_receive(:system_call).with(%(curl -s -I -XPOST "#{url}"))
+        services.post(url)
+      end
+    end
+  end
+end

data/spec/dynport_tools/settings_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+describe DynportTools::Settings do
+  let(:redis) { Redis.new }
+  let(:time) { Time.parse("2011-02-03 04:05:06") }
+  
+  before(:each) do
+    DynportTools::Settings.defaults = nil
+    DynportTools::Settings.redis = redis
+    redis.del("settings")
+    redis.del("settings/updated_at")
+    DynportTools::Settings.instance_variable_set("@all", nil)
+    DynportTools::Settings.instance_variable_set("@cached_at", nil)
+  end
+  
+  it "allows setting a redis connection" do
+    r = double("redis2")
+    DynportTools::Settings.redis = r
+    DynportTools::Settings.redis.should == r
+  end
+  
+  it "allows addings new settings" do
+    DynportTools::Settings.set(:refresh, 11)
+    DynportTools::Settings.defaults[:refresh].should == 11
+  end
+  
+  it "returns the correct defaults" do
+    DynportTools::Settings.set(:refresh, 12)
+    DynportTools::Settings.refresh.should == 12
+  end
+  
+  it "allows setting of multiple settings at once" do
+    DynportTools::Settings.set(:a => 1, :b => 2)
+    DynportTools::Settings.a.should == 1
+    DynportTools::Settings.b.should == 2
+  end
+  
+  describe "#all" do
+    it "fetches the correct values" do
+      redis.hset("settings", "a", "1")
+      redis.hset("settings", "b", "2")
+      DynportTools::Settings.all.should == { "a" => "1", "b" => "2" }
+    end
+    
+    it "caches the fetched records" do
+      Timecop.freeze(time) do
+        redis.hset("settings", "a", "1")
+        redis.hset("settings", "b", "2")
+        DynportTools::Settings.all
+        DynportTools::Settings.instance_variable_get("@all").should == { "a" => "1", "b" => "2" }
+        DynportTools::Settings.instance_variable_get("@cached_at").should == time
+      end
+    end
+    
+    it "returns the cached settings when not expired" do
+      DynportTools::Settings.stub(:expired?).and_return false
+      DynportTools::Settings.instance_variable_set("@all", { "c" => "3" })
+      DynportTools::Settings.all.should == { "c" => "3" }
+    end
+  end
+  
+  describe "#expired?" do
+    it "returns false when @cached_at is nil" do
+      DynportTools::Settings.should_not be_expired
+    end
+    
+    it "returns false when cached_at exactly 60 seconds ago" do
+      Timecop.freeze(time) do
+        DynportTools::Settings.instance_variable_set("@cached_at", time - 60)
+        DynportTools::Settings.should_not be_expired
+      end
+    end
+    
+    it "returns true when exactly 61 seconds ago" do
+      Timecop.freeze(time) do
+        DynportTools::Settings.instance_variable_set("@cached_at", time - 61)
+        DynportTools::Settings.should be_expired
+      end
+    end
+  end
+  
+  describe "#changed?" do
+    it "returns true when redis value != cached_at" do
+      Timecop.freeze(time) do
+        redis.set("settings/updated_at", time.to_i + 1)
+        DynportTools::Settings.should be_changed
+      end
+    end
+    
+    it "returns true when both nil" do
+      DynportTools::Settings.instance_variable_set("@cached_at", nil)
+      DynportTools::Settings.should be_changed
+    end
+    
+    it "false when redis value == cached_at" do
+      Timecop.freeze(time) do
+        DynportTools::Settings.instance_variable_set("@cached_at", time)
+        redis.set("settings/updated_at", time.to_i)
+        DynportTools::Settings.should_not be_changed
+      end
+    end
+  end
+  
+  describe "#set_value" do
+    it "resets the @all variable" do
+      DynportTools::Settings.set :refresh, 11
+      DynportTools::Settings.instance_variable_set("@all", { "b" => "2" })
+      DynportTools::Settings.set_value(:refresh, 12)
+      DynportTools::Settings.instance_variable_get("@all").should == { "refresh" => "12" }
+    end
+    
+    it "sets the updated_at field" do
+      Timecop.freeze(Time.at(11)) do
+        DynportTools::Settings.set :refresh, 11
+        DynportTools::Settings.set_value(:refresh, 12)
+        redis.get("settings/updated_at").should == "11"
+      end
+    end
+  end
+  
+  describe "dsl" do
+    before(:each) do
+      DynportTools::Settings.redis = redis
+      redis.del("settings")
+    end
+    
+    it "sets the defaults array" do
+      DynportTools::Settings.set :refresh, 11
+      DynportTools::Settings.defaults[:refresh].should == 11
+    end
+    
+    it "allows addings settings" do
+      DynportTools::Settings.set :refresh, 10
+      DynportTools::Settings.refresh.should == 10
+    end
+    
+    it "uses settings stored in redis" do
+      redis.hset("settings", "refresh", 20)
+      DynportTools::Settings.set(:refresh, 10)
+      DynportTools::Settings.refresh.should == 20
+    end
+    
+    it "returns the correct types for integers" do
+      redis.hset("settings", "enabled", true)
+      DynportTools::Settings.set(:enabled, false)
+      DynportTools::Settings.enabled.should == true
+    end
+    
+    describe "with boolean methods" do
+      it "adds the enable_<key>! method" do
+        DynportTools::Settings.set(:new_feature, true)
+        DynportTools::Settings.disable_new_feature!
+        DynportTools::Settings.new_feature.should == false
+      end
+      
+      it "adds the enable_<key>! method" do
+        DynportTools::Settings.set(:new_feature, false)
+        DynportTools::Settings.enable_new_feature!
+        DynportTools::Settings.new_feature.should == true
+      end
+      
+      it "adds the new_feature?`method" do
+        DynportTools::Settings.set(:new_feature, false)
+        DynportTools::Settings.new_feature?.should == false
+        DynportTools::Settings.enable_new_feature!
+        DynportTools::Settings.new_feature?.should == true
+      end
+    end
+    
+    it "allows setting of settings" do
+      DynportTools::Settings.set(:refresh, 12)
+      DynportTools::Settings.set_refresh(13)
+      DynportTools::Settings.refresh.should == 13
+      redis.hgetall("settings")["refresh"].should == "13"
+    end
+  end
+end