payshares-xdr 0.0.2

data/spec/lib/xdr/array_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe XDR::Array, "#read" do
+  let(:empty) { XDR::Array[XDR::Int, 0] }
+  let(:one)   { XDR::Array[XDR::Int, 1] }
+  let(:many)  { XDR::Array[XDR::Int, 2] }
+
+  it "decodes values correctly" do
+    expect( read empty, "" ).to eq([])
+    expect( read empty, "\x00\x00\x00\x00" ).to eq([])
+    expect( read one, "\x00\x00\x00\x00" ).to eq([0])
+    expect( read one, "\x00\x00\x00\x01" ).to eq([1])
+    expect( read many, "\x00\x00\x00\x00\x00\x00\x00\x01" ).to eq([0, 1])
+    expect( read many, "\x00\x00\x00\x01\x00\x00\x00\x01" ).to eq([1, 1])
+  end
+
+  it "raises EOFError the byte stream isn't large enough" do
+    expect{ read many, "\x00\x00\x00\x00" }.to raise_error(EOFError)
+  end
+
+  def read(reader, str)
+    io = StringIO.new(str)
+    reader.read(io)
+  end
+end
+
+describe XDR::Array, "#write" do
+  subject{ XDR::Array[XDR::Int, 2] }
+
+  it "encodes values correctly" do
+    expect(write [1,2]).to eq("\x00\x00\x00\x01\x00\x00\x00\x02")
+    expect(write [1,4]).to eq("\x00\x00\x00\x01\x00\x00\x00\x04")
+  end
+
+  it "raises a WriteError if the value is not the correct length" do
+    expect{ write nil     }.to raise_error(XDR::WriteError)
+    expect{ write []      }.to raise_error(XDR::WriteError)
+    expect{ write [1]     }.to raise_error(XDR::WriteError)
+    expect{ write [1,2,3] }.to raise_error(XDR::WriteError)
+  end
+
+  it "raises a WriteError if a child element is of the wrong type" do
+    expect{ write [nil]      }.to raise_error(XDR::WriteError)
+    expect{ write ["hi"]     }.to raise_error(XDR::WriteError)
+    expect{ write [1,2,"hi"] }.to raise_error(XDR::WriteError)
+  end
+
+  def write(val)
+    io = StringIO.new()
+    subject.write(val, io)
+    io.string
+  end
+end
+
+describe XDR::Array, "#valid?" do
+  subject{ XDR::Array[XDR::Int, 2] }
+
+  it "rejects an empty array" do
+    expect(subject.valid?([])).to be_falsey
+  end
+
+  it "accepts a filled array provided each element passes the child_type validator" do
+    expect(subject.valid?([1,2])).to be_truthy
+    expect(subject.valid?([2,3])).to be_truthy
+  end
+
+  it "rejects a filled array if any element is rejected by the child_type validator" do
+    expect(subject.valid?(["hello", "hello"])).to be_falsey
+    expect(subject.valid?([1, "hello"])).to be_falsey
+    expect(subject.valid?([1, nil])).to be_falsey
+    expect(subject.valid?([nil])).to be_falsey
+  end
+end

data/spec/lib/xdr/bool_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe XDR::Bool, ".read" do
+  subject{ XDR::Bool }
+
+  let(:false_s) {  "\x00\x00\x00\x00" }
+  let(:true_s)  {  "\x00\x00\x00\x01" }
+  let(:two)     {  "\x00\x00\x00\x02" }
+
+  it "decodes values correctly" do
+    expect(read(false_s)).to eq(false)
+    expect(read(true_s)).to eq(true)
+  end
+
+  it "raises ReadError if the decoded value is not 0 or 1" do
+    expect{ read two }.to raise_error XDR::ReadError
+  end
+
+  def read(str)
+    io = StringIO.new(str)
+    subject.read(io)
+  end
+end
+
+describe XDR::Bool, ".write" do
+  subject{ XDR::Bool }
+
+  it "encodes values correctly" do
+    expect(write false).to eq("\x00\x00\x00\x00")
+    expect(write true).to eq("\x00\x00\x00\x01")
+  end
+
+  it "raises WriteError if the value is boolean" do
+    expect{ write 1 }.to raise_error XDR::WriteError
+    expect{ write "hello" }.to raise_error XDR::WriteError
+  end
+
+  def write(val)
+    io = StringIO.new()
+    subject.write(val, io)
+    io.string
+  end
+end

data/spec/lib/xdr/concerns/converts_to_xdr_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe XDR::Concerns::ConvertsToXDR do
+  subject{ UnimplementedConvertible.new }
+
+  it "requires an implementation of #read" do
+    expect{ subject.read(StringIO.new) }.to raise_error(NotImplementedError)
+  end
+
+  it "requires an implementation of #write" do
+    expect{ subject.write(3, StringIO.new) }.to raise_error(NotImplementedError)
+  end
+
+  it "requires an implementation of #valid?" do
+    expect{ subject.valid?(3) }.to raise_error(NotImplementedError)
+  end
+end
+
+describe XDR::Concerns::ConvertsToXDR, "#to_xdr" do
+  subject{ ImplementedConvertible.new }
+
+  it "calls through to write" do
+    expect(subject).to receive(:write).with("hiya", kind_of(StringIO))
+    subject.to_xdr("hiya")
+  end
+end
+
+describe XDR::Concerns::ConvertsToXDR, "#from_xdr" do
+  subject{ ImplementedConvertible.new }
+
+  it "calls through to write" do
+    expect(subject).to receive(:read).with(kind_of(StringIO))
+    subject.from_xdr("hiya")
+  end
+end
+
+class UnimplementedConvertible
+  include XDR::Concerns::ConvertsToXDR
+end
+
+class ImplementedConvertible
+  include XDR::Concerns::ConvertsToXDR
+
+  def read(io)
+    read_bytes(4)
+  end
+
+  def write(val, io)
+    io.write(val)
+  end
+
+  def valid?(val)
+    true
+  end
+end

data/spec/lib/xdr/concerns/reads_bytes_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+class TestReader
+  include XDR::Concerns::ReadsBytes
+  public :read_bytes
+end
+
+
+describe XDR::Concerns::ReadsBytes, "#read_bytes"  do
+  subject{ TestReader.new }
+
+  it "raises EOFError when the requested length goes beyond the length of the stream" do
+    expect{ read("", 1) }.to raise_error(EOFError)
+    expect{ read("", 2) }.to raise_error(EOFError)
+    expect{ read("", 10) }.to raise_error(EOFError)
+    expect{ read("\x00\x01\x02", 4) }.to raise_error(EOFError)
+    expect{ read("\x00\x01\x02", 10) }.to raise_error(EOFError)
+  end
+
+  it "returns the read data" do
+    expect(read("", 0)).to eq("")
+    expect(read("\x00", 1)).to eq("\x00")
+    expect(read("\x01", 1)).to eq("\x01")
+    expect(read("\x00\x01\x02", 3)).to eq("\x00\x01\x02")
+  end
+
+  def read(str, length)
+    io = StringIO.new(str)
+    subject.read_bytes(io, length)
+  end
+end

data/spec/lib/xdr/double_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+
+describe XDR::Double, ".read" do
+
+  it "decodes values correctly" do
+    expect(read("\x00\x00\x00\x00\x00\x00\x00\x00")).to eq(0.0)
+    expect(read("\x80\x00\x00\x00\x00\x00\x00\x00")).to eq(-0.0)
+    expect(read("\x3F\xF0\x00\x00\x00\x00\x00\x00")).to eq(1.0)
+    expect(read("\xBF\xF0\x00\x00\x00\x00\x00\x00")).to eq(-1.0)
+  end
+
+  def read(str)
+    io = StringIO.new(str)
+    subject.read(io)
+  end
+end
+
+describe XDR::Double, ".write" do
+  it "encodes values correctly" do
+    expect(write 0.0).to  eq_bytes("\x00\x00\x00\x00\x00\x00\x00\x00")
+    expect(write -0.0).to eq_bytes("\x80\x00\x00\x00\x00\x00\x00\x00")
+    expect(write 1.0).to  eq_bytes("\x3F\xF0\x00\x00\x00\x00\x00\x00")
+    expect(write -1.0).to eq_bytes("\xBF\xF0\x00\x00\x00\x00\x00\x00")
+  end
+
+  it "raises a WriteError when the value is not Float" do
+    expect{ write 3 }.to      raise_error(XDR::WriteError)
+    expect{ write "hi" }.to   raise_error(XDR::WriteError)
+    expect{ write "1.0" }.to  raise_error(XDR::WriteError)
+  end
+
+  def write(val)
+    io = StringIO.new()
+    subject.write(val, io)
+    io.string
+  end
+end

data/spec/lib/xdr/dsl/enum_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+
+describe XDR::DSL::Enum, "#member" do
+  subject do
+    Class.new(XDR::Enum) do
+      member :one, 1
+      member :two, 2
+    end
+  end
+
+  it "adds to the members collection of the class" do
+    expect(subject.members.length).to eq(2)
+    expect(subject.members[:one]).to eq(subject.one)
+    expect(subject.members[:two]).to eq(subject.two)
+  end
+
+  it "raises ArgumentError if a non-fixnum value is used" do
+    expect {
+      Class.new(XDR::Enum) do
+        member :one, "hi!"
+      end
+    }.to raise_error(ArgumentError)
+  end
+end
+
+describe XDR::DSL::Enum, "#seal" do
+  subject do
+    Class.new(XDR::Enum) do
+      member :one, 1
+      member :two, 2
+      seal
+    end
+  end
+
+  it "marks the class as sealed" do
+    expect(subject.sealed).to eq(true)
+  end
+
+  it "prevents you from adding members after being sealed" do
+    expect{ subject.member :three, 3 }.to raise_error(ArgumentError)
+  end
+
+end

data/spec/lib/xdr/dsl/struct_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+
+describe XDR::DSL::Struct, "#attribute" do
+  subject do
+    Class.new(XDR::Struct) do
+      attribute :attr1, XDR::Int
+      attribute :attr2, XDR::String[]
+    end
+  end
+
+
+  it "adds to the fields collection of the class" do
+    expect(subject.fields.length).to eq(2)
+    expect(subject.fields[:attr1]).to eq(XDR::Int)
+    expect(subject.fields[:attr2]).to be_a(XDR::String)
+  end
+
+
+
+  it "raises ArgumentError if a non-convertible type is used" do
+    expect do
+      Class.new(XDR::Struct) do
+        attribute :attr1, String
+      end
+    end.to raise_error(ArgumentError)
+  end
+
+end

data/spec/lib/xdr/dsl/union_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+
+describe XDR::DSL::Union, "#switch" do
+
+  it "allows symbols in switch declarations" do
+    expect do
+      klass = Class.new(XDR::Union) do
+        switch_on ResultType, :type
+        switch :ok
+      end
+
+      klass.new(:ok)
+    end.to_not raise_error
+  end
+
+  class ResultType < XDR::Enum
+    member :ok, 0
+    member :error, 1
+    seal
+  end
+end

data/spec/lib/xdr/enum_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+class TestColor < XDR::Enum
+  member :red, 0
+  member :green, 1
+  member :even_more_green, 3
+
+  seal
+end
+
+describe XDR::Enum, ".read" do
+  let(:zero) { "\x00\x00\x00\x00" }
+  let(:one) { "\x00\x00\x00\x01" }
+  let(:two) { "\x00\x00\x00\x02" }
+
+  subject{ TestColor }
+
+  it "decodes values correctly" do
+    expect( read zero ).to eq(TestColor.red)
+    expect( read one ).to eq(TestColor.green)
+  end
+
+  it "raises EnumValueError if the decoded value is not in the defined constants" do
+    expect{ read two }.to raise_error XDR::EnumValueError
+  end
+
+  def read(str)
+    io = StringIO.new(str)
+    subject.read(io)
+  end
+end
+
+describe XDR::Enum, ".write" do
+  subject{ TestColor }
+
+  it "encodes values correctly" do
+    expect( write TestColor.red ).to   eq("\x00\x00\x00\x00")
+    expect( write TestColor.green ).to eq("\x00\x00\x00\x01")
+  end
+
+  it "raises WriteError if value isn't a member" do
+    expect{ write 0 }.to raise_error XDR::WriteError
+    expect{ write 1 }.to raise_error XDR::WriteError
+  end
+
+  def write(val)
+    io = StringIO.new()
+    subject.write(val, io)
+    io.string
+  end
+end
+
+describe XDR::Enum, ".from_name" do
+  subject{ TestColor }
+
+  it "returns the correct value" do
+    expect(subject.from_name("red")).to eq(TestColor.red)
+  end
+
+  it "allows various casings, strings or symbols" do
+    expect(subject.from_name("even_more_green")).to eq(TestColor.even_more_green)
+    expect(subject.from_name("EVEN_MORE_GREEN")).to eq(TestColor.even_more_green)
+    expect(subject.from_name(:even_more_green)).to eq(TestColor.even_more_green)
+    expect(subject.from_name(:EVEN_MORE_GREEN)).to eq(TestColor.even_more_green)
+  end
+
+  it "raises EnumNameError when the name is not a member" do
+    expect{ subject.from_name("chartreuse")}.to raise_error(XDR::EnumNameError)
+  end
+end

data/spec/lib/xdr/float_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+
+describe XDR::Float, ".read" do
+  it "decodes values correctly" do
+    expect(read("\x00\x00\x00\x00")).to eq(0.0)
+    expect(read("\x80\x00\x00\x00")).to eq(-0.0)
+    expect(read("\x3F\x80\x00\x00")).to eq(1.0)
+    expect(read("\xBF\x80\x00\x00")).to eq(-1.0)
+  end
+
+  def read(str)
+    io = StringIO.new(str)
+    subject.read(io)
+  end
+end
+
+describe XDR::Float, ".write" do
+  it "encodes values correctly" do
+    expect(write(0.0)).to eq_bytes("\x00\x00\x00\x00")
+    expect(write(-0.0)).to eq_bytes("\x80\x00\x00\x00")
+    expect(write(1.0)).to eq_bytes("\x3F\x80\x00\x00")
+    expect(write(-1.0)).to eq_bytes("\xBF\x80\x00\x00")
+  end
+
+  it "raises a WriteError when the value is not Float" do
+    expect{ write 3 }.to raise_error(XDR::WriteError)
+    expect{ write "hello" }.to raise_error(XDR::WriteError)
+    expect{ write "1.0" }.to raise_error(XDR::WriteError)
+  end
+
+  def write(val)
+    io = StringIO.new()
+    subject.write(val, io)
+    io.string
+  end
+end