r509-validity-redis 0.4.1 → 0.4.2

data/lib/r509/validity/redis/checker.rb

@@ -1,30 +1,30 @@
 require "r509"
 
 module R509::Validity::Redis
-    class Checker < R509::Validity::Checker
-        def initialize(redis)
-            raise ArgumentError.new("Redis must be provided") if redis.nil?
-            @redis = redis
-        end
+  class Checker < R509::Validity::Checker
+    def initialize(redis)
+      raise ArgumentError.new("Redis must be provided") if redis.nil?
+      @redis = redis
+    end
 
-        # @return [R509::Validity::Status]
-        def check(issuer,serial)
-            raise ArgumentError.new("Serial and issuer must be provided") if serial.to_s.empty? or issuer.to_s.empty?
+    # @return [R509::Validity::Status]
+    def check(issuer,serial)
+      raise ArgumentError.new("Serial and issuer must be provided") if serial.to_s.empty? or issuer.to_s.empty?
 
-            hash = @redis.hgetall("cert:#{issuer}:#{serial}")
-            if not hash.nil? and hash.has_key?("status")
-                R509::Validity::Status.new(
-                    :status => hash["status"].to_i,
-                    :revocation_time => hash["revocation_time"].to_i || nil,
-                    :revocation_reason => hash["revocation_reason"].to_i || 0
-                )
-            else
-                R509::Validity::Status.new(:status => R509::Validity::UNKNOWN)
-            end
-        end
+      hash = @redis.hgetall("cert:#{issuer}:#{serial}")
+      if not hash.nil? and hash.has_key?("status")
+        R509::Validity::Status.new(
+          :status => hash["status"].to_i,
+          :revocation_time => hash["revocation_time"].to_i || nil,
+          :revocation_reason => hash["revocation_reason"].to_i || 0
+        )
+      else
+        R509::Validity::Status.new(:status => R509::Validity::UNKNOWN)
+      end
+    end
 
-        def is_available?
-            (@redis.ping == "PONG")? true : false
-        end
+    def is_available?
+      (@redis.ping == "PONG")? true : false
     end
+  end
 end

data/lib/r509/validity/redis/version.rb

@@ -1,7 +1,7 @@
 module R509
-    module Validity
-        module Redis
-            VERSION="0.4.1"
-        end
+  module Validity
+    module Redis
+      VERSION="0.4.2"
     end
+  end
 end

data/lib/r509/validity/redis/writer.rb

@@ -1,43 +1,43 @@
 require "r509"
 
 module R509::Validity::Redis
-    class Writer < R509::Validity::Writer
-        def initialize(redis)
-            raise ArgumentError.new("Redis must be provided") if redis.nil?
-            @redis = redis
-        end
+  class Writer < R509::Validity::Writer
+    def initialize(redis)
+      raise ArgumentError.new("Redis must be provided") if redis.nil?
+      @redis = redis
+    end
 
-        def issue(issuer, serial)
-            raise ArgumentError.new("Serial and issuer must be provided") if serial.to_s.empty? or issuer.to_s.empty?
-            cert = @redis.hgetall("cert:#{issuer}:#{serial}")
-            if cert.nil? or not cert.has_key?("status")
-                @redis.hmset("cert:#{issuer}:#{serial}", "status", 0)
-            else
-                raise R509::R509Error.new("Serial #{serial} for issuer #{issuer} is already present")
-            end
-        end
+    def issue(issuer, serial)
+      raise ArgumentError.new("Serial and issuer must be provided") if serial.to_s.empty? or issuer.to_s.empty?
+      cert = @redis.hgetall("cert:#{issuer}:#{serial}")
+      if cert.nil? or not cert.has_key?("status")
+        @redis.hmset("cert:#{issuer}:#{serial}", "status", 0)
+      else
+        raise R509::R509Error.new("Serial #{serial} for issuer #{issuer} is already present")
+      end
+    end
 
-        def revoke(issuer, serial, revocation_time=Time.now.to_i, reason=0)
-            raise ArgumentError.new("Serial and issuer must be provided") if serial.to_s.empty? or issuer.to_s.empty?
-            @redis.hmset("cert:#{issuer}:#{serial}",
-                "status", 1,
-                "revocation_time", revocation_time || Time.now.to_i,
-                "revocation_reason", reason || 0
-            )
-        end
+    def revoke(issuer, serial, revocation_time=Time.now.to_i, reason=0)
+      raise ArgumentError.new("Serial and issuer must be provided") if serial.to_s.empty? or issuer.to_s.empty?
+      @redis.hmset("cert:#{issuer}:#{serial}",
+        "status", 1,
+        "revocation_time", revocation_time || Time.now.to_i,
+        "revocation_reason", reason || 0
+      )
+    end
 
-        def unrevoke(issuer, serial)
-            raise ArgumentError.new("Serial and issuer must be provided") if serial.to_s.empty? or issuer.to_s.empty?
-            cert = @redis.hgetall("cert:#{issuer}:#{serial}")
-            if cert.nil? or not cert.has_key?("status")
-                raise R509::R509Error.new("Serial #{serial} for issuer #{issuer} is not present")
-            else
-                @redis.hmset("cert:#{issuer}:#{serial}", "status", 0)
-            end
-        end
+    def unrevoke(issuer, serial)
+      raise ArgumentError.new("Serial and issuer must be provided") if serial.to_s.empty? or issuer.to_s.empty?
+      cert = @redis.hgetall("cert:#{issuer}:#{serial}")
+      if cert.nil? or not cert.has_key?("status")
+        raise R509::R509Error.new("Serial #{serial} for issuer #{issuer} is not present")
+      else
+        @redis.hmset("cert:#{issuer}:#{serial}", "status", 0)
+      end
+    end
 
-        def is_available?
-            (@redis.ping == "PONG")? true : false
-        end
+    def is_available?
+      (@redis.ping == "PONG")? true : false
     end
+  end
 end

data/spec/checker_spec.rb

@@ -1,68 +1,68 @@
 require "spec_helper"
 
 describe R509::Validity::Redis::Checker do
-    context "constructor" do
-        it "when redis is nil" do
-            expect { R509::Validity::Redis::Checker.new(nil) }.to raise_error(ArgumentError, "Redis must be provided")
-        end
+  context "constructor" do
+    it "when redis is nil" do
+      expect { R509::Validity::Redis::Checker.new(nil) }.to raise_error(ArgumentError, "Redis must be provided")
     end
-    context "check" do
-        it "throws an exception when issuer is nil/empty string" do
-            redis = double("redis")
-            checker = R509::Validity::Redis::Checker.new(redis)
-            expect { checker.check(nil,123) }.to raise_error(ArgumentError, "Serial and issuer must be provided")
-        end
-        it "throws an exception when serial is nil/empty string" do
-            redis = double("redis")
-            checker = R509::Validity::Redis::Checker.new(redis)
-            expect { checker.check("abcdef",nil) }.to raise_error(ArgumentError, "Serial and issuer must be provided")
-        end
-        it "gets unknown when serial is not found (returns {})" do
-            redis = double("redis")
-            checker = R509::Validity::Redis::Checker.new(redis)
-            redis.should_receive(:hgetall).with("cert:abcdef:123").and_return({})
-            status = checker.check("abcdef",123)
-            status.status.should == R509::Validity::UNKNOWN
-        end
-        it "gets unknown when serial is not found (returns nil)" do
-            redis = double("redis")
-            checker = R509::Validity::Redis::Checker.new(redis)
-            redis.should_receive(:hgetall).with("cert:abcdef:123").and_return(nil)
-            status = checker.check("abcdef",123)
-            status.status.should == R509::Validity::UNKNOWN
-        end
-        it "gets valid" do
-            redis = double("redis")
-            checker = R509::Validity::Redis::Checker.new(redis)
-            redis.should_receive(:hgetall).with("cert:abcdef:123").and_return({"status" => "0" })
-            status = checker.check("abcdef",123)
-            status.status.should == R509::Validity::VALID
-            status.revocation_time.should == 0
-            status.revocation_reason.should == 0
-        end
-        it "gets revoked with revocation time and reason" do
-            redis = double("redis")
-            checker = R509::Validity::Redis::Checker.new(redis)
-            redis.should_receive(:hgetall).with("cert:abcdef:123").and_return({"status" => "1", "revocation_time" => "789", "revocation_reason" => "5" })
-            status = checker.check("abcdef",123)
-            status.status.should == R509::Validity::REVOKED
-            status.revocation_time.should == 789
-            status.revocation_reason.should == 5
-        end
+  end
+  context "check" do
+    it "throws an exception when issuer is nil/empty string" do
+      redis = double("redis")
+      checker = R509::Validity::Redis::Checker.new(redis)
+      expect { checker.check(nil,123) }.to raise_error(ArgumentError, "Serial and issuer must be provided")
+    end
+    it "throws an exception when serial is nil/empty string" do
+      redis = double("redis")
+      checker = R509::Validity::Redis::Checker.new(redis)
+      expect { checker.check("abcdef",nil) }.to raise_error(ArgumentError, "Serial and issuer must be provided")
+    end
+    it "gets unknown when serial is not found (returns {})" do
+      redis = double("redis")
+      checker = R509::Validity::Redis::Checker.new(redis)
+      redis.should_receive(:hgetall).with("cert:abcdef:123").and_return({})
+      status = checker.check("abcdef",123)
+      status.status.should == R509::Validity::UNKNOWN
+    end
+    it "gets unknown when serial is not found (returns nil)" do
+      redis = double("redis")
+      checker = R509::Validity::Redis::Checker.new(redis)
+      redis.should_receive(:hgetall).with("cert:abcdef:123").and_return(nil)
+      status = checker.check("abcdef",123)
+      status.status.should == R509::Validity::UNKNOWN
+    end
+    it "gets valid" do
+      redis = double("redis")
+      checker = R509::Validity::Redis::Checker.new(redis)
+      redis.should_receive(:hgetall).with("cert:abcdef:123").and_return({"status" => "0" })
+      status = checker.check("abcdef",123)
+      status.status.should == R509::Validity::VALID
+      status.revocation_time.should == 0
+      status.revocation_reason.should == 0
+    end
+    it "gets revoked with revocation time and reason" do
+      redis = double("redis")
+      checker = R509::Validity::Redis::Checker.new(redis)
+      redis.should_receive(:hgetall).with("cert:abcdef:123").and_return({"status" => "1", "revocation_time" => "789", "revocation_reason" => "5" })
+      status = checker.check("abcdef",123)
+      status.status.should == R509::Validity::REVOKED
+      status.revocation_time.should == 789
+      status.revocation_reason.should == 5
+    end
+  end
+  context "is available" do
+    it "returns true if redis is available" do
+      redis = double("redis")
+      redis.should_receive(:ping).and_return("PONG")
+      checker = R509::Validity::Redis::Checker.new(redis)
+      checker.is_available?.should == true
     end
-    context "is available" do
-        it "returns true if redis is available" do
-            redis = double("redis")
-            redis.should_receive(:ping).and_return("PONG")
-            checker = R509::Validity::Redis::Checker.new(redis)
-            checker.is_available?.should == true
-        end
 
-        it "raises error if redis is unavailable" do
-            redis = double("redis")
-            redis.should_receive(:ping).and_return(StandardError)
-            checker = R509::Validity::Redis::Checker.new(redis)
-            checker.is_available?.should == false
-        end
+    it "raises error if redis is unavailable" do
+      redis = double("redis")
+      redis.should_receive(:ping).and_return(StandardError)
+      checker = R509::Validity::Redis::Checker.new(redis)
+      checker.is_available?.should == false
     end
+  end
 end

data/spec/spec_helper.rb

@@ -1,7 +1,5 @@
-if (RUBY_VERSION.split('.')[1].to_i > 8)
-    require 'simplecov'
-    SimpleCov.start
-end
+require 'simplecov'
+SimpleCov.start
 
 $:.unshift File.expand_path("../../lib", __FILE__)
 $:.unshift File.expand_path("../", __FILE__)

data/spec/writer_spec.rb

@@ -1,127 +1,127 @@
 require "spec_helper"
 
 describe R509::Validity::Redis::Writer do
-    context "constructor" do
-        it "when redis is nil" do
-            expect { R509::Validity::Redis::Writer.new(nil) }.to raise_error(ArgumentError, "Redis must be provided")
-        end
+  context "constructor" do
+    it "when redis is nil" do
+      expect { R509::Validity::Redis::Writer.new(nil) }.to raise_error(ArgumentError, "Redis must be provided")
     end
+  end
 
-    context "issue" do
-        it "when issuer is nil/empty string" do
-            redis = double("redis")
-            writer = R509::Validity::Redis::Writer.new(redis)
-            expect { writer.issue(nil,123) }.to raise_error(ArgumentError, "Serial and issuer must be provided")
-        end
-        it "when serial is nil/empty string" do
-            redis = double("redis")
-            writer = R509::Validity::Redis::Writer.new(redis)
-            expect { writer.issue("abcdef",nil) }.to raise_error(ArgumentError, "Serial and issuer must be provided")
-        end
-        it "when serial/issuer is provided (check returns nil)" do
-            redis = double("redis")
-            writer = R509::Validity::Redis::Writer.new(redis)
-            redis.should_receive(:hgetall).with("cert:abcdef:123").and_return(nil)
-            redis.should_receive(:hmset).with("cert:abcdef:123", "status", 0)
-            writer.issue("abcdef",123)
-        end
-        it "when serial/issuer is provided (check returns {})" do
-            redis = double("redis")
-            writer = R509::Validity::Redis::Writer.new(redis)
-            redis.should_receive(:hgetall).with("cert:abcdef:123").and_return({})
-            redis.should_receive(:hmset).with("cert:abcdef:123", "status", 0)
-            writer.issue("abcdef",123)
-        end
-        it "when serial/issuer is already present" do
-            redis = double("redis")
-            writer = R509::Validity::Redis::Writer.new(redis)
-            redis.should_receive(:hgetall).with("cert:abcdef:123").and_return({"status"=>0})
-            expect { writer.issue("abcdef",123) }.to raise_error(R509::R509Error, "Serial 123 for issuer abcdef is already present")
-        end
+  context "issue" do
+    it "when issuer is nil/empty string" do
+      redis = double("redis")
+      writer = R509::Validity::Redis::Writer.new(redis)
+      expect { writer.issue(nil,123) }.to raise_error(ArgumentError, "Serial and issuer must be provided")
     end
+    it "when serial is nil/empty string" do
+      redis = double("redis")
+      writer = R509::Validity::Redis::Writer.new(redis)
+      expect { writer.issue("abcdef",nil) }.to raise_error(ArgumentError, "Serial and issuer must be provided")
+    end
+    it "when serial/issuer is provided (check returns nil)" do
+      redis = double("redis")
+      writer = R509::Validity::Redis::Writer.new(redis)
+      redis.should_receive(:hgetall).with("cert:abcdef:123").and_return(nil)
+      redis.should_receive(:hmset).with("cert:abcdef:123", "status", 0)
+      writer.issue("abcdef",123)
+    end
+    it "when serial/issuer is provided (check returns {})" do
+      redis = double("redis")
+      writer = R509::Validity::Redis::Writer.new(redis)
+      redis.should_receive(:hgetall).with("cert:abcdef:123").and_return({})
+      redis.should_receive(:hmset).with("cert:abcdef:123", "status", 0)
+      writer.issue("abcdef",123)
+    end
+    it "when serial/issuer is already present" do
+      redis = double("redis")
+      writer = R509::Validity::Redis::Writer.new(redis)
+      redis.should_receive(:hgetall).with("cert:abcdef:123").and_return({"status"=>0})
+      expect { writer.issue("abcdef",123) }.to raise_error(R509::R509Error, "Serial 123 for issuer abcdef is already present")
+    end
+  end
 
-    context "revoke" do
-        it "when issuer is nil/empty string" do
-            redis = double("redis")
-            writer = R509::Validity::Redis::Writer.new(redis)
-            expect { writer.revoke(nil,123) }.to raise_error(ArgumentError, "Serial and issuer must be provided")
-        end
-        it "when serial is nil/empty string" do
-            redis = double("redis")
-            writer = R509::Validity::Redis::Writer.new(redis)
-            expect { writer.revoke("abcdef",nil) }.to raise_error(ArgumentError, "Serial and issuer must be provided")
-        end
-        it "when time and reason aren't provided" do
-            redis = double("redis")
-            writer = R509::Validity::Redis::Writer.new(redis)
-            redis.should_receive(:hmset).with("cert:abcdef:123", "status", 1, "revocation_time", Time.now.to_i, "revocation_reason", 0)
-            writer.revoke("abcdef",123)
-        end
-        it "when time and reason are nil" do
-            redis = double("redis")
-            writer = R509::Validity::Redis::Writer.new(redis)
-            redis.should_receive(:hmset).with("cert:abcdef:123", "status", 1, "revocation_time", Time.now.to_i, "revocation_reason", 0)
-            writer.revoke("abcdef",123, nil, nil)
-        end
-        it "when time is provided, but not reason" do
-            redis = double("redis")
-            writer = R509::Validity::Redis::Writer.new(redis)
-            redis.should_receive(:hmset).with("cert:abcdef:123", "status", 1, "revocation_time", 100, "revocation_reason", 0)
-            writer.revoke("abcdef",123, 100)
-        end
-        it "when time and reason are provided" do
-            redis = double("redis")
-            writer = R509::Validity::Redis::Writer.new(redis)
-            redis.should_receive(:hmset).with("cert:abcdef:123", "status", 1, "revocation_time", 100, "revocation_reason", 2)
-            writer.revoke("abcdef",123, 100, 2)
-        end
+  context "revoke" do
+    it "when issuer is nil/empty string" do
+      redis = double("redis")
+      writer = R509::Validity::Redis::Writer.new(redis)
+      expect { writer.revoke(nil,123) }.to raise_error(ArgumentError, "Serial and issuer must be provided")
+    end
+    it "when serial is nil/empty string" do
+      redis = double("redis")
+      writer = R509::Validity::Redis::Writer.new(redis)
+      expect { writer.revoke("abcdef",nil) }.to raise_error(ArgumentError, "Serial and issuer must be provided")
+    end
+    it "when time and reason aren't provided" do
+      redis = double("redis")
+      writer = R509::Validity::Redis::Writer.new(redis)
+      redis.should_receive(:hmset).with("cert:abcdef:123", "status", 1, "revocation_time", Time.now.to_i, "revocation_reason", 0)
+      writer.revoke("abcdef",123)
+    end
+    it "when time and reason are nil" do
+      redis = double("redis")
+      writer = R509::Validity::Redis::Writer.new(redis)
+      redis.should_receive(:hmset).with("cert:abcdef:123", "status", 1, "revocation_time", Time.now.to_i, "revocation_reason", 0)
+      writer.revoke("abcdef",123, nil, nil)
     end
+    it "when time is provided, but not reason" do
+      redis = double("redis")
+      writer = R509::Validity::Redis::Writer.new(redis)
+      redis.should_receive(:hmset).with("cert:abcdef:123", "status", 1, "revocation_time", 100, "revocation_reason", 0)
+      writer.revoke("abcdef",123, 100)
+    end
+    it "when time and reason are provided" do
+      redis = double("redis")
+      writer = R509::Validity::Redis::Writer.new(redis)
+      redis.should_receive(:hmset).with("cert:abcdef:123", "status", 1, "revocation_time", 100, "revocation_reason", 2)
+      writer.revoke("abcdef",123, 100, 2)
+    end
+  end
 
-    context "unrevoke" do
-        it "when issuer is nil/empty string" do
-            redis = double("redis")
-            writer = R509::Validity::Redis::Writer.new(redis)
-            expect { writer.unrevoke(nil,123) }.to raise_error(ArgumentError, "Serial and issuer must be provided")
-        end
-        it "when serial is nil/empty string" do
-            redis = double("redis")
-            writer = R509::Validity::Redis::Writer.new(redis)
-            expect { writer.unrevoke("abcdef",nil) }.to raise_error(ArgumentError, "Serial and issuer must be provided")
-        end
-        it "when serial/issuer is provided" do
-            redis = double("redis")
-            writer = R509::Validity::Redis::Writer.new(redis)
-            redis.should_receive(:hgetall).with("cert:abcdef:123").and_return({"status" => 1})
-            redis.should_receive(:hmset).with("cert:abcdef:123", "status", 0)
-            writer.unrevoke("abcdef",123)
-        end
-        it "when cert record doesn't exist (nil)" do
-            redis = double("redis")
-            writer = R509::Validity::Redis::Writer.new(redis)
-            redis.should_receive(:hgetall).with("cert:abcdef:123").and_return(nil)
-            expect { writer.unrevoke("abcdef",123) }.to raise_error(R509::R509Error, "Serial 123 for issuer abcdef is not present")
-        end
-        it "when cert record doesn't exist ({})" do
-            redis = double("redis")
-            writer = R509::Validity::Redis::Writer.new(redis)
-            redis.should_receive(:hgetall).with("cert:abcdef:123").and_return({})
-            expect { writer.unrevoke("abcdef",123) }.to raise_error(R509::R509Error, "Serial 123 for issuer abcdef is not present")
-        end
+  context "unrevoke" do
+    it "when issuer is nil/empty string" do
+      redis = double("redis")
+      writer = R509::Validity::Redis::Writer.new(redis)
+      expect { writer.unrevoke(nil,123) }.to raise_error(ArgumentError, "Serial and issuer must be provided")
+    end
+    it "when serial is nil/empty string" do
+      redis = double("redis")
+      writer = R509::Validity::Redis::Writer.new(redis)
+      expect { writer.unrevoke("abcdef",nil) }.to raise_error(ArgumentError, "Serial and issuer must be provided")
+    end
+    it "when serial/issuer is provided" do
+      redis = double("redis")
+      writer = R509::Validity::Redis::Writer.new(redis)
+      redis.should_receive(:hgetall).with("cert:abcdef:123").and_return({"status" => 1})
+      redis.should_receive(:hmset).with("cert:abcdef:123", "status", 0)
+      writer.unrevoke("abcdef",123)
     end
+    it "when cert record doesn't exist (nil)" do
+      redis = double("redis")
+      writer = R509::Validity::Redis::Writer.new(redis)
+      redis.should_receive(:hgetall).with("cert:abcdef:123").and_return(nil)
+      expect { writer.unrevoke("abcdef",123) }.to raise_error(R509::R509Error, "Serial 123 for issuer abcdef is not present")
+    end
+    it "when cert record doesn't exist ({})" do
+      redis = double("redis")
+      writer = R509::Validity::Redis::Writer.new(redis)
+      redis.should_receive(:hgetall).with("cert:abcdef:123").and_return({})
+      expect { writer.unrevoke("abcdef",123) }.to raise_error(R509::R509Error, "Serial 123 for issuer abcdef is not present")
+    end
+  end
 
-    context "is available" do
-        it "returns true if redis is available" do
-            redis = double("redis")
-            redis.should_receive(:ping).and_return("PONG")
-            writer = R509::Validity::Redis::Writer.new(redis)
-            writer.is_available?.should == true
-        end
+  context "is available" do
+    it "returns true if redis is available" do
+      redis = double("redis")
+      redis.should_receive(:ping).and_return("PONG")
+      writer = R509::Validity::Redis::Writer.new(redis)
+      writer.is_available?.should == true
+    end
 
-        it "raises error if redis is unavailable" do
-            redis = double("redis")
-            redis.should_receive(:ping).and_return(StandardError)
-            writer = R509::Validity::Redis::Writer.new(redis)
-            writer.is_available?.should == false
-        end
+    it "raises error if redis is unavailable" do
+      redis = double("redis")
+      redis.should_receive(:ping).and_return(StandardError)
+      writer = R509::Validity::Redis::Writer.new(redis)
+      writer.is_available?.should == false
     end
+  end
 end