xdr 3.0.1 → 3.0.2

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

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

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

@@ -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,40 +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
-
-  it "raises a ReadError when the padding isn't zeros" do
-    expect{ read "\x00\x00\x01\x01" }.to raise_error(XDR::ReadError)
-  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