burlap 1.0.0

data/spec/burlap/core_ext/hash_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+RSpec.describe Hash do
+  describe "#to_burlap" do
+    subject(:burlap) { { some: "hash" }.to_burlap }
+
+    it "returns a string" do
+      expect(burlap).to be_a_kind_of(String)
+    end
+
+    it "is correct" do
+      expect(burlap).to eq("<map><type></type><string>some</string><string>hash</string></map>")
+    end
+  end
+end

data/spec/burlap/core_ext/integer_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe Integer do
+  describe "#to_burlap" do
+    # https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html
+    # maximum value an int can have, 2**31-1.
+    # minimum value an int can have, -2**31.
+    context "when within 32bit signed limits" do
+      it "encodes the Integer as 'int'" do
+        expect(5.to_burlap).to eq("<int>5</int>")
+        expect(-5.to_burlap).to eq("<int>-5</int>")
+
+        expect(2_147_483_647.to_burlap).to eq("<int>2147483647</int>")
+        expect(-2_147_483_648.to_burlap).to eq("<int>-2147483648</int>")
+      end
+    end
+
+    context "when outside 32bit signed limits" do
+      it "encodes the Integer as 'java.math.BigDecimal'" do
+        expect(2_147_483_648.to_burlap).to eq("<map><type>java.math.BigDecimal</type><string>value</string><string>2147483648</string></map>")
+        expect(-2_147_483_649.to_burlap).to eq("<map><type>java.math.BigDecimal</type><string>value</string><string>-2147483649</string></map>")
+
+        expect(999_999_999_999_999_999.to_burlap).to eq("<map><type>java.math.BigDecimal</type><string>value</string><string>999999999999999999</string></map>")
+        expect(-999_999_999_999_999_999.to_burlap).to eq("<map><type>java.math.BigDecimal</type><string>value</string><string>-999999999999999999</string></map>")
+      end
+    end
+  end
+end

data/spec/burlap/core_ext/nil_class_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+RSpec.describe NilClass do
+  describe "#to_burlap" do
+    subject(:burlap) { nil.to_burlap }
+
+    it "returns a string" do
+      expect(burlap).to be_a_kind_of(String)
+    end
+
+    it "is correct" do
+      expect(burlap).to eq("<null></null>")
+    end
+  end
+end

data/spec/burlap/core_ext/object_spec.rb

@@ -0,0 +1,62 @@
+require "spec_helper"
+
+RSpec.describe Object do
+  describe "#to_burlap" do
+    subject(:burlap) { described_class.new.to_burlap }
+
+    it "returns a string" do
+      expect(burlap).to be_a_kind_of(String)
+    end
+
+    it "invokes Burlap::Hash with type of classname" do
+      hash = instance_double(Burlap::Hash)
+      expect(Burlap::Hash).to receive(:[]).with([], "Object").and_return(hash)
+      expect(hash).to receive(:to_burlap).and_return("<my>xml</my>")
+
+      expect(burlap).to eq("<my>xml</my>")
+    end
+
+    context "with instance variables" do
+      subject(:burlap) { InstanceVariablesObject.new.to_burlap }
+
+      let(:klass) do
+        Class.new do
+          def initialize
+            @one = 1
+            @two = "something here"
+            @three = :bingo
+          end
+        end
+      end
+
+      before do
+        stub_const("InstanceVariablesObject", klass)
+        @doc = Nokogiri::XML(@result)
+      end
+
+      it "returns a string" do
+        expect(burlap).to be_a_kind_of(String)
+      end
+
+      it "decompiles into burlap" do
+        xml_string = <<-XML
+          <map>
+            <type>InstanceVariablesObject</type>
+
+            <string>one</string>
+            <int>1</int>
+
+            <string>three</string>
+            <string>bingo</string>
+
+            <string>two</string>
+            <string>something here</string>
+          </map>
+        XML
+
+        format_xml_as_burlap(xml_string)
+        expect(burlap).to eq(xml_string)
+      end
+    end
+  end
+end

data/spec/burlap/core_ext/string_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+RSpec.describe String do
+  describe "#to_burlap" do
+    subject(:burlap) { input_string.to_burlap }
+
+    context "with normal string" do
+      let(:input_string) { "some string" }
+
+      it "returns a string" do
+        expect(burlap).to be_a_kind_of(described_class)
+      end
+
+      it "is correct" do
+        expect(burlap).to eq("<string>some string</string>")
+      end
+    end
+
+    context "with html unsafe content" do
+      let(:input_string) { "<script type='text/js'>hello</script>" }
+
+      it "returns escaped html" do
+        expect(burlap).to match(%r{&lt;script type='text/js'&gt;hello&lt;/script&gt;})
+      end
+    end
+  end
+end

data/spec/burlap/core_ext/symbol_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+RSpec.describe Symbol do
+  describe "#to_burlap" do
+    subject(:burlap) { :some_value.to_burlap }
+
+    it "returns a string" do
+      expect(burlap).to be_a_kind_of(String)
+    end
+
+    it "is correct" do
+      expect(burlap).to eq("<string>some_value</string>")
+    end
+  end
+end

data/spec/burlap/core_ext/time_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+RSpec.describe Time do
+  describe "#to_burlap" do
+    subject(:burlap) { described_class.utc(2011, 9, 11, 10, 0).to_burlap }
+
+    it "returns a string" do
+      expect(burlap).to be_a_kind_of(String)
+    end
+
+    it "is correct" do
+      expect(burlap).to eq("<date>20110911T100000.000Z</date>")
+    end
+
+    it "does not contain dashes" do
+      expect(burlap).not_to include("-")
+    end
+
+    it "does not contain colons" do
+      expect(burlap).not_to include(":")
+    end
+  end
+end

data/spec/burlap/core_ext/true_class_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+RSpec.describe TrueClass do
+  describe "#to_burlap" do
+    before do
+      @result = true.to_burlap
+    end
+
+    it "returns a string" do
+      expect(@result).to be_a_kind_of(String)
+    end
+
+    it "is correct" do
+      expect(@result).to eq("<boolean>1</boolean>")
+    end
+  end
+end

data/spec/burlap/default_resolver_spec.rb

@@ -0,0 +1,140 @@
+require "spec_helper"
+
+RSpec.describe Burlap::DefaultResolver do
+  subject(:resolver) { described_class.new }
+
+  describe "#mappings" do
+    it "defaults to a hash" do
+      expect(resolver.mappings).to eq({})
+    end
+
+    context "when passed a name and block" do
+      it "stores a single mapping" do
+        expect(resolver.mappings["first"]).to be_nil
+
+        resolver.mappings("first") do
+          "result of call"
+        end
+
+        result = resolver.mappings["first"]
+
+        expect(result).not_to be_nil
+        expect(result).to be_a_kind_of(Proc)
+        expect(result.call).to eq("result of call")
+      end
+    end
+
+    context "when passed more than one name at once" do
+      it "stores the same block against multiple mappings" do
+        resolver.mappings("first", "second") do
+          "result of call"
+        end
+
+        result = resolver.mappings["first"]
+        expect(result).not_to be_nil
+        expect(result).to respond_to(:call)
+        expect(result.call).to eq("result of call")
+
+        result = resolver.mappings["second"]
+        expect(result).not_to be_nil
+        expect(result).to respond_to(:call)
+        expect(result.call).to eq("result of call")
+      end
+    end
+  end
+
+  describe ".convert_to_native" do
+    subject(:resolver) { Burlap.resolver }
+
+    context "when input is 'int'" do
+      let(:burlap_tag) { Burlap::BaseTag.new(name: "int", value: "15") }
+
+      it "is parsed into ruby" do
+        expect(resolver.convert_to_native(burlap_tag)).to eq(15)
+      end
+    end
+
+    context "when input is 'double" do
+      let(:burlap_tag) { Burlap::BaseTag.new(name: "double", value: "1.5") }
+
+      it "is parsed into ruby" do
+        expect(resolver.convert_to_native(burlap_tag)).to eq(1.5)
+      end
+    end
+
+    context "when input is 'string" do
+      let(:burlap_tag) { Burlap::BaseTag.new(name: "string", value: "some string value") }
+
+      it "is parsed into ruby" do
+        expect(resolver.convert_to_native(burlap_tag)).to eq("some string value")
+      end
+    end
+
+    context "when input is 'null" do
+      let(:burlap_tag) { Burlap::BaseTag.new(name: "null", value: "") }
+
+      it "is parsed into ruby" do
+        expect(resolver.convert_to_native(burlap_tag)).to eq(nil)
+      end
+    end
+
+    context "when input is 'with 'boolean'" do
+      let(:burlap_tag) { Burlap::BaseTag.new(name: "boolean", value: value) }
+
+      context "with true (1)" do
+        let(:value) { "1" }
+
+        it "parses true" do
+          expect(resolver.convert_to_native(burlap_tag)).to be(true)
+        end
+      end
+
+      context "with false (0)" do
+        let(:value) { "0" }
+
+        it "parses false" do
+          expect(resolver.convert_to_native(burlap_tag)).to be(false)
+        end
+      end
+    end
+
+    describe ".parse" do
+      subject(:parsed_burlap) { Burlap.parse(burlap) }
+
+      context "with empty array" do
+        let(:burlap) { "<list><type>[java.lang.Integer</type><length>0</length></list>" }
+
+        it "parses an empty array" do
+          expect(parsed_burlap).to eq([])
+        end
+      end
+
+      context "when single element" do
+        let(:burlap) { "<list><type>[string</type><length>1</length><string>1</string></list>" }
+
+        it "parses an array" do
+          expect(parsed_burlap).to eq(["1"])
+        end
+      end
+
+      context "when multiple elements" do
+        let(:burlap) { %{<list><type></type><length>3</length><int>0</int><double>1.3</double><string>foobar</string></list>} }
+
+        it "parses an array" do
+          expect(parsed_burlap).to eq([0, 1.3, "foobar"])
+        end
+      end
+
+      context "with 'base64' encoded" do
+        let(:burlap) { "<base64>#{encoded}</base64>" }
+        let(:decoded) { "some string of some text" }
+        let(:encoded) { Base64.encode64(decoded) }
+
+        it "parses and return as a string" do
+          expect(parsed_burlap).to be_a_kind_of(String)
+          expect(parsed_burlap).to eq(decoded)
+        end
+      end
+    end
+  end
+end

data/spec/burlap/error_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+RSpec.describe Burlap::Error do
+  it "inherits from standard error" do
+    expect(described_class.ancestors).to include(StandardError)
+  end
+end

data/spec/burlap/hash_spec.rb

@@ -0,0 +1,234 @@
+require "spec_helper"
+
+RSpec.describe Burlap::Hash do
+  it "inherits from ordered hash" do
+    expect(described_class.ancestors).to include(ActiveSupport::OrderedHash)
+  end
+
+  it { is_expected.to respond_to(:__type__) }
+  it { is_expected.to respond_to(:__type__=) }
+
+  describe "#__type__" do
+    it "defaults to an empty string" do
+      expect(described_class.new.__type__).to eq("")
+    end
+  end
+
+  describe "#[]" do
+    subject(:burlap_hash) { described_class[input] }
+
+    context "when input is a Hash" do
+      let(:input) { {} }
+
+      it "is compatible with Hash#[]" do
+        expect(burlap_hash.keys).to eq([])
+        expect(burlap_hash.values).to eq([])
+      end
+
+      it "is empty string" do
+        expect(burlap_hash.__type__).to eq("")
+      end
+    end
+
+    context "when one argument is given" do
+      let(:input) { { "one" => "two", "three" => "four" } }
+
+      it "is compatible with Hash#[]" do
+        expect(burlap_hash.keys).to eq(%w[one three])
+        expect(burlap_hash.values).to eq(%w[two four])
+      end
+
+      it "is empty string" do
+        expect(burlap_hash.__type__).to eq("")
+      end
+    end
+
+    context "when a __type__ is passed" do
+      let(:input) { { some: "options", __type__: "is ignored" } }
+
+      it "is compatible with Hash#[]" do
+        expect(burlap_hash.keys).to eq(%i[some __type__])
+        expect(burlap_hash.values).to eq(["options", "is ignored"])
+      end
+
+      it "is empty string" do
+        expect(burlap_hash.__type__).to eq("")
+      end
+    end
+
+    context "when a second argument sets type directly" do
+      subject(:burlap_hash) { described_class[input, "com.java.hashmap"] }
+
+      context "without a passed __type__" do
+        let(:input) { { some: "options" } }
+
+        it "is compatible with Hash#[]" do
+          expect(burlap_hash.keys).to eq([:some])
+          expect(burlap_hash.values).to eq(["options"])
+        end
+
+        it "sets __type__ directly" do
+          expect(burlap_hash.__type__).to eq("com.java.hashmap")
+        end
+      end
+
+      context "with a passed __type__" do
+        let(:input) { { some: "options", __type__: "is ignored" } }
+
+        it "is compatible with Hash#[]" do
+          expect(burlap_hash.keys).to eq(%i[some __type__])
+          expect(burlap_hash.values).to eq(["options", "is ignored"])
+        end
+
+        it "sets __type__ directly" do
+          expect(burlap_hash.__type__).to eq("com.java.hashmap")
+        end
+      end
+    end
+  end
+
+  describe "#inspect" do
+    subject(:burlap_hash) { described_class[[%w[one two], [:three, 4]], "Fred"] }
+
+    it "does not contain OrderedHash" do
+      expect(burlap_hash.inspect).not_to include("OrderedHash")
+    end
+
+    it "starts with Burlap::Hash" do
+      expect(burlap_hash.inspect).to match(/#<Burlap::Hash/)
+    end
+
+    it "contains the hash, inspected" do
+      expect(burlap_hash.inspect).to include(%({"one"=>"two", :three=>4}))
+    end
+
+    it "contains the type, inspected" do
+      expect(burlap_hash.inspect).to include(%{__type__="Fred"})
+    end
+  end
+
+  describe "#to_burlap" do
+    subject(:burlap) { burlap_hash.to_burlap }
+
+    let(:burlap_hash) { described_class[{ value: "something" }, "org.ruby-lang.string"] }
+
+    context "wrapping a string" do
+      # <map>
+      #   <type>org.ruby-lang.string</type>
+      #   <string>value</string>
+      #   <string>something</string>
+      # </map>
+
+      it "returns a string" do
+        expect(burlap).to be_a_kind_of(String)
+      end
+
+      it "has a map root" do
+        expect(burlap).to match(/^<map>/)
+        expect(burlap).to match(%r{</map>$})
+      end
+
+      it "has a nested type node" do
+        expect(burlap).to match(%r{<type>org.ruby-lang.string</type>})
+      end
+
+      it "has nested value nodes" do
+        expect(burlap).to match(%r{<string>value</string>})
+        expect(burlap).to match(%r{<string>something</string>})
+      end
+    end
+
+    context "wrapping multiple keys" do
+      let(:burlap_hash) { described_class[[["name", "caius durling"], ["age", 101]], "burlap.user"] }
+
+      before do
+        @doc = Nokogiri::XML(burlap)
+      end
+
+      it "returns a string" do
+        expect(burlap).to be_a_kind_of(String)
+      end
+
+      it "is correct" do
+        xml_string = <<-XML
+        <map>
+          <type>burlap.user</type>
+          <string>name</string>
+          <string>caius durling</string>
+          <string>age</string>
+          <int>101</int>
+        </map>
+        XML
+
+        format_xml_as_burlap(xml_string)
+        expect(burlap).to eq(xml_string)
+      end
+
+      it "has a type element" do
+        expect(burlap).to match(%r{<type>burlap.user</type>})
+      end
+
+      it "has a name keypair" do
+        expect(burlap).to match(%r{<string>name</string><string>caius durling</string>})
+      end
+
+      it "has an age keypair" do
+        expect(burlap).to match(%r{<string>age</string><int>101</int>})
+      end
+    end
+
+    context "wrapping nested keys" do
+      let(:burlap_hash) { described_class[[["people", { "name" => "caius durling", "age" => 101 }]], "burlap-peoples"] }
+
+      it "returns a string" do
+        expect(burlap).to be_a_kind_of(String)
+      end
+
+      it "is generated properly, including nested elements" do
+        xml_string = <<-XML
+          <map>
+            <type>burlap-peoples</type>
+
+            <string>people</string>
+            <map>
+              <type></type>
+
+              <string>name</string>
+              <string>caius durling</string>
+
+              <string>age</string>
+              <int>101</int>
+            </map>
+
+          </map>
+        XML
+        xml_string.gsub!(/(^|\n)\s*/m, "")
+        expect(burlap).to eq(xml_string)
+      end
+    end
+
+    context "wrapping empty arrays" do
+      let(:burlap_hash) { described_class[{ numbers: [] }] }
+
+      it "returns a string" do
+        expect(burlap).to be_a_kind_of(String)
+      end
+
+      it "is generated properly" do
+        xml_string = <<-XML
+          <map>
+            <type></type>
+
+            <string>numbers</string>
+            <list>
+              <type></type>
+              <length>0</length>
+            </list>
+          </map>
+        XML
+        xml_string.gsub!(/(^|\n)\s*/m, "")
+        expect(burlap).to eq(xml_string)
+      end
+    end
+  end
+end

data/spec/burlap/listener_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+RSpec.describe Burlap::Listener do
+  describe ".parse" do
+    subject(:result) { Burlap.parse(reply) }
+
+    context "when response is no such method" do
+      let(:reply) { File.read("spec/data/no_such_method.burlap") }
+
+      before { raise if reply.nil? }
+
+      it "parses successfully" do
+        expect(result).to be_a_kind_of(OpenStruct)
+        expect(result.code).to eq("NoSuchMethodException")
+        expect(result.message).to eq("The service has no method named: getUserID")
+      end
+    end
+
+    describe "when response is record not found" do
+      let(:reply) { File.read("spec/data/record_not_found.burlap") }
+
+      before { raise if reply.nil? }
+
+      it "parses successfully" do
+        expect(result).to be_a_kind_of(Burlap::Fault)
+        expect(result.code).to eq("ServiceException")
+        expect(result.message).to eq("No row with the given identifier exists: [com.sapienter.jbilling.server.user.db.UserDTO#21]")
+      end
+    end
+  end
+end

data/spec/burlap/node_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+RSpec.describe Burlap::Node do
+  describe "#to_burlap" do
+    subject(:burlap) { described_class.new(name: "name", value: value).to_burlap }
+
+    context "with a string" do
+      let(:value) { "updateUser" }
+
+      it "returns a string" do
+        expect(burlap).to be_a_kind_of(String)
+      end
+
+      it "puts name in brackets" do
+        expect(burlap).to eq("<name>updateUser</name>")
+      end
+    end
+
+    context "with UTF8 characters" do
+      let(:value) { "Håva" }
+
+      it "uses decimal escaping for utf8 characters" do
+        expect(burlap).to eq(%{<name>H&#229;va</name>})
+      end
+    end
+
+    context "with nested XML" do
+      let(:value) { "<length>1</length>" }
+
+      it "returns a string" do
+        expect(burlap).to be_a_kind_of(String)
+      end
+
+      it "does not escape the value containing XML" do
+        expect(burlap).to eq("<name><length>1</length></name>")
+      end
+    end
+  end
+end