krypt 0.0.1

data/spec/krypt/codec/base64_decoder_spec.rb

@@ -0,0 +1,94 @@
+require 'rspec'
+require 'krypt'
+require 'stringio'
+
+describe Krypt::Base64::Decoder do 
+
+  let(:klass) { Krypt::Base64::Decoder }
+
+  def write_string(s)
+    io = StringIO.new
+    b64 = klass.new(io)
+    b64 << s
+    b64.close
+    io.string
+  end
+
+  def read_string(s)
+    io = StringIO.new(s)
+    b64 = klass.new(io)
+    begin
+      b64.read
+    ensure
+      b64.close
+    end
+  end
+
+  describe "new" do
+    it "mandates a single parameter, the underlying IO" do
+      klass.new(StringIO.new).should be_an_instance_of klass
+    end
+
+    context "takes a block after whose execution the IO is closed" do
+      specify "successful execution of the block" do
+        io = StringIO.new
+        klass.new(io) do |b64|
+          b64 << "Zg=="
+        end
+        io.closed?.should == true
+      end
+
+      specify "failed execution of the block" do
+        io = StringIO.new
+        begin
+          klass.new(io) do |b64|
+            raise RuntimeError.new 
+          end
+        rescue RuntimeError
+          io.closed?.should == true
+        end
+      end
+    end
+  end
+
+  shared_examples_for "RFC 4648 Base64 decode" do |meth|
+    context "RFC 4648 test vectors" do
+      specify "empty string" do
+        send(meth, "").should == ""
+      end
+
+      specify "f" do
+        send(meth, "Zg==").should == "f"
+      end
+
+      specify "fo" do
+        send(meth, "Zm8=").should == "fo"
+      end
+
+      specify "foo" do
+        send(meth, "Zm9v").should == "foo"
+      end
+
+      specify "foob" do
+        send(meth, "Zm9vYg==").should == "foob"
+      end
+
+      specify "fooba" do
+        send(meth, "Zm9vYmE=").should == "fooba"
+      end
+
+      specify "foobar" do
+        send(meth, "Zm9vYmFy").should == "foobar"
+      end
+    end
+  end
+
+  describe "#read" do
+    it_behaves_like "RFC 4648 Base64 decode", :read_string
+  end
+
+  describe "#write" do
+    it_behaves_like "RFC 4648 Base64 decode", :write_string
+  end
+
+end

data/spec/krypt/codec/base64_encoder_spec.rb

@@ -0,0 +1,94 @@
+require 'rspec'
+require 'krypt'
+require 'stringio'
+
+describe Krypt::Base64::Encoder do 
+
+  let(:klass) { Krypt::Base64::Encoder }
+
+  def write_string(s)
+    io = StringIO.new
+    b64 = klass.new(io)
+    b64 << s
+    b64.close
+    io.string
+  end
+
+  def read_string(s)
+    io = StringIO.new(s)
+    b64 = klass.new(io)
+    begin
+      b64.read
+    ensure
+      b64.close
+    end
+  end
+
+  describe "new" do
+    it "mandates a single parameter, the underlying IO" do
+      klass.new(StringIO.new).should be_an_instance_of klass
+    end
+
+    context "takes a block after whose execution the IO is closed" do
+      specify "successful execution of the block" do
+        io = StringIO.new
+        klass.new(io) do |b64|
+          b64 << "test"
+        end
+        io.closed?.should == true
+      end
+
+      specify "failed execution of the block" do
+        io = StringIO.new
+        begin
+          klass.new(io) do |b64|
+            raise RuntimeError.new 
+          end
+        rescue RuntimeError
+          io.closed?.should == true
+        end
+      end
+    end
+  end
+
+  shared_examples_for "RFC 4648 Base64 encode" do |meth|
+    context "RFC 4648 test vectors" do
+      specify "empty string" do
+        send(meth, "").should == ""
+      end
+
+      specify "f" do
+        send(meth, "f").should == "Zg=="
+      end
+
+      specify "fo" do
+        send(meth, "fo").should == "Zm8="
+      end
+
+      specify "foo" do
+        send(meth, "foo").should == "Zm9v"
+      end
+
+      specify "foob" do
+        send(meth, "foob").should == "Zm9vYg=="
+      end
+
+      specify "fooba" do
+        send(meth, "fooba").should == "Zm9vYmE="
+      end
+
+      specify "foobar" do
+        send(meth, "foobar").should == "Zm9vYmFy"
+      end
+    end
+  end
+
+  describe "#read" do
+    it_behaves_like "RFC 4648 Base64 encode", :read_string
+  end
+
+  describe "#write" do
+    it_behaves_like "RFC 4648 Base64 encode", :write_string
+  end
+  
+end

data/spec/krypt/codec/base64_mixed_spec.rb

@@ -0,0 +1,16 @@
+require 'rspec'
+require 'krypt'
+require 'stringio'
+
+describe "Krypt::Base64 integration" do 
+
+  let(:dec) { Krypt::Base64::Decoder }
+  let(:enc) { Krypt::Base64::Encoder }
+
+  require_relative 'identity_shared'
+
+  describe "Encoder and Decoder stacked on top of each other" do
+    it_behaves_like "Identity codec", Krypt::Base64::Encoder, Krypt::Base64::Decoder
+  end
+end
+

data/spec/krypt/codec/hex_decoder_spec.rb

@@ -0,0 +1,94 @@
+require 'rspec'
+require 'krypt'
+require 'stringio'
+
+describe Krypt::Hex::Decoder do 
+
+  let(:klass) { Krypt::Hex::Decoder }
+
+  def write_string(s)
+    io = StringIO.new
+    hex = klass.new(io)
+    hex << s
+    hex.close
+    io.string
+  end
+
+  def read_string(s)
+    io = StringIO.new(s)
+    hex = klass.new(io)
+    begin
+      hex.read
+    ensure
+      hex.close
+    end
+  end
+
+  describe "new" do
+    it "mandates a single parameter, the underlying IO" do
+      klass.new(StringIO.new).should be_an_instance_of klass
+    end
+
+    context "takes a block after whose execution the IO is closed" do
+      specify "successful execution of the block" do
+        io = StringIO.new
+        klass.new(io) do |hex|
+          hex << "42"
+        end
+        io.closed?.should == true
+      end
+
+      specify "failed execution of the block" do
+        io = StringIO.new
+        begin
+          klass.new(io) do |hex|
+            raise RuntimeError.new 
+          end
+        rescue RuntimeError
+          io.closed?.should == true
+        end
+      end
+    end
+  end
+
+  shared_examples_for "RFC 4648 hex decode" do |meth|
+    context "RFC 4648 test vectors" do
+      specify "empty string" do
+        send(meth, "").should == ""
+      end
+
+      specify "f" do
+        send(meth, "66").should == "f"
+      end
+
+      specify "fo" do
+        send(meth, "666f").should == "fo"
+      end
+
+      specify "foo" do
+        send(meth, "666f6f").should == "foo"
+      end
+
+      specify "foob" do
+        send(meth, "666f6f62").should == "foob"
+      end
+
+      specify "fooba" do
+        send(meth, "666f6f6261").should == "fooba"
+      end
+
+      specify "foobar" do
+        send(meth, "666f6f626172").should == "foobar"
+      end
+    end
+  end
+
+  describe "#read" do
+    it_behaves_like "RFC 4648 hex decode", :read_string
+  end
+
+  describe "#write" do
+    it_behaves_like "RFC 4648 hex decode", :write_string
+  end
+
+end

data/spec/krypt/codec/hex_encoder_spec.rb

@@ -0,0 +1,94 @@
+require 'rspec'
+require 'krypt'
+require 'stringio'
+
+describe Krypt::Hex::Encoder do 
+
+  let(:klass) { Krypt::Hex::Encoder }
+
+  def write_string(s)
+    io = StringIO.new
+    hex = klass.new(io)
+    hex << s
+    hex.close
+    io.string
+  end
+
+  def read_string(s)
+    io = StringIO.new(s)
+    hex = klass.new(io)
+    begin
+      hex.read
+    ensure
+      hex.close
+    end
+  end
+
+  describe "new" do
+    it "mandates a single parameter, the underlying IO" do
+      klass.new(StringIO.new).should be_an_instance_of klass
+    end
+
+    context "takes a block after whose execution the IO is closed" do
+      specify "successful execution of the block" do
+        io = StringIO.new
+        klass.new(io) do |hex|
+          hex << "test"
+        end
+        io.closed?.should == true
+      end
+
+      specify "failed execution of the block" do
+        io = StringIO.new
+        begin
+          klass.new(io) do |hex|
+            raise RuntimeError.new 
+          end
+        rescue RuntimeError
+          io.closed?.should == true
+        end
+      end
+    end
+  end
+
+  shared_examples_for "RFC 4648 hex encode" do |meth|
+    context "RFC 4648 test vectors" do
+      specify "empty string" do
+        send(meth, "").should == ""
+      end
+
+      specify "f" do
+        send(meth, "f").should == "66"
+      end
+
+      specify "fo" do
+        send(meth, "fo").should == "666f"
+      end
+
+      specify "foo" do
+        send(meth, "foo").should == "666f6f"
+      end
+
+      specify "foob" do
+        send(meth, "foob").should == "666f6f62"
+      end
+
+      specify "fooba" do
+        send(meth, "fooba").should == "666f6f6261"
+      end
+
+      specify "foobar" do
+        send(meth, "foobar").should == "666f6f626172"
+      end
+    end
+  end
+
+  describe "#read" do
+    it_behaves_like "RFC 4648 hex encode", :read_string
+  end
+
+  describe "#write" do
+    it_behaves_like "RFC 4648 hex encode", :write_string
+  end
+
+end

data/spec/krypt/codec/hex_mixed_spec.rb

@@ -0,0 +1,17 @@
+require 'rspec'
+require 'krypt'
+require 'stringio'
+
+describe "Krypt::Hex integration" do 
+
+  let(:dec) { Krypt::Hex::Decoder }
+  let(:enc) { Krypt::Hex::Encoder }
+
+  require_relative 'identity_shared'
+
+  describe "Encoder and Decoder stacked on top of each other" do
+    it_behaves_like "Identity codec", Krypt::Hex::Encoder, Krypt::Hex::Decoder
+  end
+end
+
+

data/spec/krypt/codec/identity_shared.rb

@@ -0,0 +1,119 @@
+shared_examples_for "Identity codec" do |encoder, decoder|
+
+  let(:plain) { "test" * 1000 }
+  let(:encoded) do
+    io = StringIO.new
+    enc = encoder.new(io)
+    enc << ("test" * 1000)
+    enc.close
+    io.string
+  end
+
+  context "read_encoded" do
+    subject do
+      io = StringIO.new(encoded)
+      codec = encoder.new(decoder.new(io))
+      result = ""
+      while (c = codec.read(chunk_size))
+        result << c
+      end
+      result
+    end
+
+    context "single byte" do
+      let(:chunk_size) { 1 }
+      it { subject.should == encoded }
+    end
+
+    context "chunks of 64" do
+      let(:chunk_size) { 64 }
+      it { subject.should == encoded }
+    end
+
+    context "chunks of 3" do
+      let(:chunk_size) { 3 }
+      it { subject.should == encoded }
+    end
+  end
+
+  context "read_plain" do
+    subject do
+      io = StringIO.new(plain)
+      codec = decoder.new(encoder.new(io))
+      result = ""
+      while (c = codec.read(chunk_size))
+        result << c
+      end
+      result
+    end
+
+    context "single byte" do
+      let(:chunk_size) { 1 }
+      it { subject.should == plain }
+    end
+
+    context "chunks of 64" do
+      let(:chunk_size) { 64 }
+      it { subject.should == plain }
+    end
+
+    context "chunks of 3" do
+      let(:chunk_size) { 3 }
+      it { subject.should == plain }
+    end
+  end
+
+  context "write_encoded" do
+    subject do
+      io = StringIO.new
+      codec = dec.new(enc.new(io))
+      0.step(encoded.size, chunk_size) do |i|
+        codec << encoded.slice(i, chunk_size)
+      end
+      codec.close
+      io.string
+    end
+
+    context "single byte" do
+      let(:chunk_size) { 1 }
+      it { subject.should == encoded }
+    end
+
+    context "chunks of 64" do
+      let(:chunk_size) { 64 }
+      it { subject.should == encoded }
+    end
+
+    context "chunks of 3" do
+      let(:chunk_size) { 3 }
+      it { subject.should == encoded }
+    end
+  end
+
+  context "write_plain" do
+    subject do
+      io = StringIO.new
+      codec = enc.new(dec.new(io))
+      0.step(plain.size, chunk_size) do |i|
+        codec << plain.slice(i, chunk_size)
+      end
+      codec.close
+      io.string
+    end
+
+    context "single byte" do
+      let(:chunk_size) { 1 }
+      it { subject.should == plain }
+    end
+
+    context "chunks of 64" do
+      let(:chunk_size) { 64 }
+      it { subject.should == plain }
+    end
+
+    context "chunks of 3" do
+      let(:chunk_size) { 3 }
+      it { subject.should == plain }
+    end
+  end
+end