xdr 0.1.0 → 3.0.2

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

@@ -1,69 +0,0 @@
-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
-
-describe XDR::DSL::Union, "#switch_on" do
-  klass = nil
-
-  it "allows int types" do
-    expect do
-      klass = Class.new(XDR::Union) do
-        switch_on XDR::Int, :type
-        switch 0
-        switch 1
-      end
-    end.to_not raise_error
-
-    expect{ klass.new(0) }.to_not raise_error
-    expect{ klass.new(1) }.to_not raise_error
-    expect{ klass.new(2) }.to raise_error(XDR::InvalidSwitchError)
-  end
-
-  it "allows unsigned int types" do
-    expect do
-      klass = Class.new(XDR::Union) do
-        switch_on XDR::UnsignedInt, :type
-        switch 0
-        switch 1
-      end
-    end.to_not raise_error
-
-    expect{ klass.new(0) }.to_not raise_error
-    expect{ klass.new(1) }.to_not raise_error
-    expect{ klass.new(2) }.to raise_error(XDR::InvalidSwitchError)
-    expect{ klass.new(-1) }.to raise_error(XDR::InvalidSwitchError)
-  end
-
-  it "allows bool types", :focus do
-    klass = nil
-
-    expect do
-      klass = Class.new(XDR::Union) do
-        switch_on XDR::Bool, :type
-        switch true
-      end
-    end.to_not raise_error
-
-    expect{ klass.new(true) }.to_not raise_error
-    expect{ klass.new(false) }.to raise_error(XDR::InvalidSwitchError)
-  end
-end

data/spec/lib/xdr/enum_spec.rb

@@ -1,70 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

data/spec/lib/xdr/hyper_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-
-describe XDR::Hyper, ".read" do
-
-  it "decodes values correctly" do
-    expect(read("\x00\x00\x00\x00\x00\x00\x00\x00")).to eq(0)
-    expect(read("\x00\x00\x00\x00\x00\x00\x00\x01")).to eq(1)
-    expect(read("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF")).to eq(-1)
-    expect(read("\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF")).to eq(2**63 - 1)
-    expect(read("\x80\x00\x00\x00\x00\x00\x00\x00")).to eq(-(2**63))
-  end
-
-  def read(str)
-    io = StringIO.new(str)
-    subject.read(io)
-  end
-end
-
-describe XDR::Hyper, ".write" do
-
-  it "decodes values correctly" do
-    expect(write 0).to eq_bytes("\x00\x00\x00\x00\x00\x00\x00\x00")
-    expect(write 1).to eq_bytes("\x00\x00\x00\x00\x00\x00\x00\x01")
-    expect(write -1).to eq_bytes("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF")
-    expect(write 2**63 - 1).to eq_bytes("\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF")
-    expect(write -(2**63)).to eq_bytes("\x80\x00\x00\x00\x00\x00\x00\x00")
-  end
-
-  it "raises WriteError when an Integer isn't passed" do
-    expect{ write 1.0 }.to raise_error(XDR::WriteError)
-    expect{ write "hi" }.to raise_error(XDR::WriteError)
-  end
-
-  def write(val)
-    io = StringIO.new()
-    subject.write(val, io)
-    io.string
-  end
-end

data/spec/lib/xdr/int_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-
-describe XDR::Int, ".read" do
-
-  it "decodes values correctly" do
-    expect(read("\x00\x00\x00\x00")).to eq(0)
-    expect(read("\x00\x00\x00\x01")).to eq(1)
-    expect(read("\xFF\xFF\xFF\xFF")).to eq(-1)
-    expect(read("\x7F\xFF\xFF\xFF")).to eq(2**31 - 1)
-    expect(read("\x80\x00\x00\x00")).to eq(-(2**31))
-  end
-
-  def read(str)
-    io = StringIO.new(str)
-    subject.read(io)
-  end
-end
-
-describe XDR::Int, ".write" do
-
-  it "decodes values correctly" do
-    expect(write 0).to eq_bytes("\x00\x00\x00\x00")
-    expect(write 1).to eq_bytes("\x00\x00\x00\x01")
-    expect(write -1).to eq_bytes("\xFF\xFF\xFF\xFF")
-    expect(write 2**31 - 1).to eq_bytes("\x7F\xFF\xFF\xFF")
-    expect(write -(2**31)).to eq_bytes("\x80\x00\x00\x00")
-  end
-
-  it "raises WriteError when an Integer isn't passed" do
-    expect{ write 1.0 }.to raise_error(XDR::WriteError)
-    expect{ write "hi" }.to raise_error(XDR::WriteError)
-  end
-
-  def write(val)
-    io = StringIO.new()
-    subject.write(val, io)
-    io.string
-  end
-end

data/spec/lib/xdr/opaque_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-
-describe XDR::Opaque, "#read" do
-  subject{ XDR::Opaque.new(3) }
-
-  it "decodes values correctly" do
-    expect(read("\x00\x00\x00\x00")).to eq("\x00\x00\x00")
-    expect(read("\x00\x01\x00\x00")).to eq("\x00\x01\x00")
-  end
-
-  def read(str)
-    io = StringIO.new(str)
-    subject.read(io)
-  end
-end
-
-describe XDR::Opaque, "#write" do
-  subject{ XDR::Opaque.new(3) }
-
-  it "encodes values correctly" do
-    expect(write("123")).to eq("123\x00")
-    expect(write("124")).to eq("124\x00")
-  end
-
-  it "raises a WriteError if the value is not the correct length" do
-    expect{ write("1234") }.to raise_error(XDR::WriteError)
-    expect{ write("12") }.to raise_error(XDR::WriteError)
-  end
-
-  def write(val)
-    io = StringIO.new()
-    subject.write(val, io)
-    io.string
-  end
-end

data/spec/lib/xdr/option_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-
-describe XDR::Option, ".read" do
-  subject{ XDR::Option[XDR::Int] }
-
-  it "decodes values correctly" do
-    expect(read "\x00\x00\x00\x01\x00\x00\x00\x00" ).to eq(0)
-    expect(read "\x00\x00\x00\x00" ).to eq(nil)
-  end
-
-  def read(str)
-    io = StringIO.new(str)
-    subject.read(io)
-  end
-end
-
-describe XDR::Option, ".write" do
-  subject{ XDR::Option[XDR::Int] }
-
-  it "decodes values correctly" do
-    expect(write 0).to eq_bytes("\x00\x00\x00\x01\x00\x00\x00\x00")
-    expect(write nil).to eq_bytes("\x00\x00\x00\x00")
-  end
-
-  it "raises WriteError when the provided value is non-nil bust invalid for the child type" do
-    expect{ write 1.0 }.to raise_error(XDR::WriteError)
-    expect{ write "hi" }.to raise_error(XDR::WriteError)
-  end
-
-  def write(val)
-    io = StringIO.new()
-    subject.write(val, io)
-    io.string
-  end
-end

data/spec/lib/xdr/quadruple_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-
-describe XDR::Quadruple, ".read" do
-  let(:zero){ "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" }
-  it "cannot decode values yet" do
-    expect{ read zero }.to raise_error(NotImplementedError)
-  end
-
-  def read(str)
-    io = StringIO.new(str)
-    subject.read(io)
-  end
-end

data/spec/lib/xdr/rpc/record_reader_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe XDR::RPC::RecordReader, "#read" do
-
-  it "decodes values correctly" do
-    empty_record = read "\x00\x00\x00\x00"
-    last_record  = read "\x80\x00\x00\x02\x00\x00"
-
-    expect(empty_record).to_not be_last
-    expect(empty_record.length).to eq(0)
-    expect(empty_record.content.string).to eq("")
-
-    expect(last_record).to be_last
-    expect(last_record.length).to eq(2)
-    expect(last_record.content.string).to eq("\x00\x00")
-  end
-
-  it "raises EOFError the byte stream isn't large enough" do
-    expect{ read "\x00\x00\x00\x01" }.to raise_error(EOFError)
-    expect{ read "\x00\x00\x00\x08\x00\x00\x00\x01" }.to raise_error(EOFError)
-  end
-
-  def read(str)
-    io = StringIO.new(str)
-    subject.read(io)
-  end
-end

data/spec/lib/xdr/string_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-
-describe XDR::String, "#read" do
-  subject{ XDR::String.new(3) }
-
-  it "decodes values correctly" do
-    expect(read("\x00\x00\x00\x00")).to eq("")
-    expect(read("\x00\x00\x00\x01h\x00\x00\x00")).to eq("h")
-    expect(read("\x00\x00\x00\x02hi\x00\x00")).to eq("hi")
-  end
-
-  it "raises a ReadError when the encoded length is greater than the allowed max" do
-    expect{ read "\x00\x00\x00\x04hiya" }.to raise_error(XDR::ReadError)
-  end
-
-  def read(str)
-    io = StringIO.new(str)
-    subject.read(io)
-  end
-end
-
-describe XDR::String, "#write" do
-  subject{ XDR::String[2] }
-
-  it "encodes values correctly" do
-    expect(write("")).to eq("\x00\x00\x00\x00")
-    expect(write("h")).to eq("\x00\x00\x00\x01h\x00\x00\x00")
-    expect(write("hi")).to eq("\x00\x00\x00\x02hi\x00\x00")
-  end
-
-  it "raises a WriteError when the provided string is too long" do
-    expect{ write "123" }.to raise_error(XDR::WriteError)
-  end
-
-  def write(val)
-    io = StringIO.new()
-    subject.write(val, io)
-    io.string
-  end
-end

data/spec/lib/xdr/struct_spec.rb

@@ -1,101 +0,0 @@
-require 'spec_helper'
-
-module StructSpec
-  class SampleError < XDR::Struct
-    attribute :code, XDR::Int
-    attribute :msg,  XDR::String[100]
-  end
-
-
-  # class SampleEnvelope < XDR::Struct
-  #   attribute :body,  XDR::VarOpaque[]
-  #   attribute :sigs,  XDR::VarArray[XDR::Opaque[32]]
-  # end
-
-  # class SampleOptions < XDR::Struct
-  #   attribute :limit,       XDR::Option[XDR::Int]
-  #   attribute :subscribed,  XDR::Option[XDR::Bool]
-  # end
-end
-
-
-describe XDR::Struct, "creation" do
-  let(:args){ {} }
-  subject{ StructSpec::SampleError.new(args) }
-
-  context "with no args" do
-    it "creates an instance" do
-      expect(subject).to be_a(StructSpec::SampleError)
-    end
-  end
-
-  context "with valid args" do
-    let(:args){{code: 3, msg: "It broke!"}}
-
-    it "assigns values correctly" do
-      expect(subject.code).to eq(3)
-      expect(subject.msg).to eq("It broke!")
-    end
-  end
-end
-
-describe XDR::Struct, "attribute assignment" do
-  subject{ StructSpec::SampleError.new }
-
-  it "roundtrips correctly" do
-    expect(subject.code).to be_nil
-    expect(subject.msg).to be_nil
-
-    subject.code = 10
-    subject.msg = "busted"
-
-    expect(subject.code).to eq(10)
-    expect(subject.msg).to eq("busted")
-  end
-end
-
-
-describe XDR::Struct, "valid?"
-describe XDR::Struct, "optional members"
-
-describe XDR::Struct, "#to_xdr" do
-  subject{ StructSpec::SampleError.new({code: 3, msg: "It broke!"}) }
-  let(:result){ subject.to_xdr }
-
-  it "serialized each field in order" do
-    expect(result[0...4]).to eq("\x00\x00\x00\x03")
-    expect(result[4...8]).to eq([9].pack("l>"))
-    expect(result[8..-1]).to eq("It broke!\x00\x00\x00")
-  end
-
-  it "raises an exception if the struct is not valid" do
-    subject.code = nil
-    expect{ result }.to raise_error(XDR::WriteError)
-  end
-
-  it "produces hex" do
-    result = subject.to_xdr(:hex)
-    expect(result).to eq("000000030000000949742062726f6b6521000000")
-  end
-
-  it "produces base64" do
-    result = subject.to_xdr(:base64)
-    expect(result).to eq("AAAAAwAAAAlJdCBicm9rZSEAAAA=")
-  end
-end
-
-
-describe XDR::Struct, ".read" do
-  subject{ StructSpec::SampleError }
-  let(:result){ read "\x00\x00\x00\x01\x00\x00\x00\x0812345678" }
-  it "decodes values correctly" do
-    expect( result ).to be_a(subject)
-    expect( result.code  ).to eq(1)
-    expect( result.msg  ).to eq("12345678")
-  end
-
-  def read(str)
-    io = StringIO.new(str)
-    subject.read(io)
-  end
-end