xnlogic-transit-ruby 0.8.572-java

data/spec/transit/reader_spec.rb

@@ -0,0 +1,170 @@
+# Copyright 2014 Cognitect. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS-IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'spec_helper'
+
+module Transit
+  describe Reader do
+    shared_examples "read without a block" do |type|
+      it "reads a single top-level #{type} element" do
+        input = {:this => [1,2,3,{:that => "the other"}]}
+
+        io = StringIO.new('', 'w+')
+        writer = Transit::Writer.new(type, io)
+        writer.write(input)
+
+        reader = Transit::Reader.new(type, StringIO.new(io.string))
+        assert { reader.read == input }
+      end
+    end
+
+    describe "reading without a block" do
+      include_examples "read without a block", :json
+      include_examples "read without a block", :json_verbose
+      include_examples "read without a block", :msgpack
+    end
+
+    shared_examples "read with a block" do |type|
+      it "reads multiple top-level #{type} elements from a single IO" do
+        inputs = ["abc",
+                  123456789012345678901234567890,
+                  [:this, :that],
+                  {:this => [1,2,3,{:that => "the other"}]}]
+        outputs = []
+
+        io = StringIO.new('', 'w+')
+        writer = Transit::Writer.new(type, io)
+        inputs.each {|i| writer.write(i)}
+        reader = Transit::Reader.new(type, StringIO.new(io.string))
+        if Transit::jruby?
+          # Ignore expected EOFException raised after the StringIO is exhausted
+          reader.read {|val| outputs << val} rescue nil
+        else
+          reader.read {|val| outputs << val}
+        end
+
+        assert { outputs == inputs }
+      end
+    end
+
+    describe "reading with a block" do
+      include_examples "read with a block", :json
+      include_examples "read with a block", :json_verbose
+      include_examples "read with a block", :msgpack
+    end
+
+    describe 'handler registration' do
+      describe 'overrides' do
+        describe 'ground types' do
+          Decoder::GROUND_TAGS.each do |ground|
+            it "prevents override of #{ground} handler" do
+              assert {
+                rescuing {
+                  Reader.new(:json, StringIO.new, :handlers => {ground => Object.new})
+                }.message =~ /ground types/ }
+            end
+          end
+        end
+
+        it 'supports override of default string handlers' do
+          io = StringIO.new("[\"~rhttp://foo.com\"]","r+")
+          reader = Reader.new(:json, io, :handlers => {"r" => Class.new { def from_rep(v) "DECODED: #{v}" end}.new})
+          assert { reader.read == ["DECODED: http://foo.com"] }
+        end
+
+        it 'supports override of default hash handlers' do
+          my_uuid_class = Class.new(String)
+          my_uuid = my_uuid_class.new(UUID.new.to_s)
+          io = StringIO.new({"~#u" => my_uuid.to_s}.to_json)
+          reader = Reader.new(:json, io, :handlers => {"u" => Class.new { define_method(:from_rep) {|v| my_uuid_class.new(v)}}.new})
+          assert { reader.read == my_uuid }
+        end
+
+        it 'supports override of the default handler' do
+          io = StringIO.new("~Xabc".to_json)
+          reader = Reader.new(:json, io, :default_handler => Class.new { def from_rep(tag,val) raise "Unacceptable: #{s}" end}.new)
+          assert { rescuing {reader.read }.message =~ /Unacceptable/ }
+        end
+      end
+
+      describe 'extensions' do
+        it 'supports string-based extensions' do
+          io = StringIO.new("~D2014-03-15".to_json)
+          reader = Reader.new(:json, io, :handlers => {"D" => Class.new { def from_rep(v) Date.parse(v) end}.new})
+          assert { reader.read == Date.new(2014,3,15) }
+        end
+
+        it 'supports hash based extensions' do
+          io = StringIO.new({"~#Times2" => 44}.to_json)
+          reader = Reader.new(:json, io, :handlers => {"Times2" => Class.new { def from_rep(v) v * 2 end}.new})
+          assert { reader.read == 88 }
+        end
+
+        it 'supports hash based extensions that return nil'  do
+          io = StringIO.new({"~#Nil" => :anything}.to_json)
+          reader = Reader.new(:json, io, :handlers => {"Nil" => Class.new { def from_rep(_) nil end}.new})
+          assert { reader.read == nil }
+        end
+
+        it 'supports hash based extensions that return false' do
+          io = StringIO.new({"~#False" => :anything}.to_json)
+          reader = Reader.new(:json, io, :handlers => {"False" => Class.new { def from_rep(_) false end}.new})
+          assert { reader.read == false }
+        end
+
+        it 'supports complex hash values' do
+          io = StringIO.new([
+                             {"~#person"=>
+                               {"~:first_name" => "Transit","~:last_name" => "Ruby","~:birthdate" => "~D2014-01-02"}},
+                             {"^0"=>
+                               {"^1" => "Transit","^2" => "Ruby","^3" => "~D2014-01-03"}}].to_json)
+
+          person_handler = Class.new do
+            def from_rep(v)
+              Person.new(v[:first_name],v[:last_name],v[:birthdate])
+            end
+          end
+          date_handler = Class.new do
+            def from_rep(v) Date.parse(v) end
+          end
+          reader = Reader.new(:json, io,
+                              :handlers => {
+                                "person" => person_handler.new,
+                                "D"      => date_handler.new})
+          expected = [Person.new("Transit", "Ruby", Date.new(2014,1,2)),
+                      Person.new("Transit", "Ruby", Date.new(2014,1,3))]
+          assert { reader.read == expected }
+        end
+      end
+
+      describe 'Dates/Times' do
+        it "delivers a UTC DateTime for a non-UTC date string" do
+          io = StringIO.new(["~t2014-04-14T12:20:50.152-05:00"].to_json)
+          reader = Reader.new(:json, io)
+          expect(Transit::DateTimeUtil.to_millis(reader.read.first)).to eq(Transit::DateTimeUtil.to_millis(DateTime.new(2014,4,14,17,20,50.152,"Z")))
+        end
+      end
+
+      describe 'edge cases found in generative testing' do
+        it 'caches nested structures correctly' do
+          io = StringIO.new(["~#cmap",[["~#point",["~n10","~n11"]],"~:foobar",["^1",["~n10","~n13"]],"^2"]].to_json)
+          reader = Reader.new(:json, io)
+          expected = {TaggedValue.new("point", [10,11]) => :foobar,
+                      TaggedValue.new("point", [10,13]) => :foobar}
+          assert { reader.read == expected }
+        end
+      end
+    end
+  end
+end

data/spec/transit/rolling_cache_spec.rb

@@ -0,0 +1,94 @@
+# Copyright 2014 Cognitect. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS-IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'spec_helper'
+
+module Transit
+  describe RollingCache do
+    describe 'writing' do
+      it 'returns the value the first time it sees it' do
+        assert { RollingCache.new.write('abcd') == 'abcd' }
+      end
+
+      it 'returns a key the 2nd thru n times it sees a value' do
+        rc = RollingCache.new
+        assert { rc.write('abcd') == 'abcd' }
+
+        key = rc.write('abcd')
+        assert { key != 'abcd' }
+
+        100.times do
+          assert { rc.write('abcd') == key }
+        end
+      end
+
+      it 'can handle CACHE_SIZE different values' do
+        rc = RollingCache.new
+        RollingCache::CACHE_SIZE.times do |i|
+          assert { rc.write("value#{i}") == "value#{i}" }
+        end
+
+        assert { rc.size == RollingCache::CACHE_SIZE }
+      end
+
+      it 'resets after CACHE_SIZE different values' do
+        rc = RollingCache.new
+        (RollingCache::CACHE_SIZE+1).times do |i|
+          assert{ rc.write("value#{i}") == "value#{i}" }
+        end
+
+        assert { rc.size == 1 }
+      end
+    end
+
+    describe ".cacheable?" do
+      it 'returns false for small strings' do
+        cache = RollingCache.new
+
+        names = random_strings(3, 500)
+        1000.times do |i|
+          name = names.sample
+          assert { !cache.cacheable?(name, false) }
+          assert { !cache.cacheable?(name, true)  }
+        end
+      end
+
+      it 'returns false for non map-keys' do
+        cache = RollingCache.new
+
+        names = random_strings(200, 500)
+        1000.times do |i|
+          name = names.sample
+          assert { !cache.cacheable?(name, false) }
+        end
+      end
+    end
+
+    describe ".cache_key?" do
+      it 'special cases map-as-array key as false' do
+        cache = RollingCache.new
+        assert { !cache.cache_key?(Transit::MAP_AS_ARRAY) }
+      end
+    end
+
+    describe 'reading' do
+      it 'returns the value, given a key that has a value in the cache' do
+        rc = RollingCache.new
+        rc.write 'abcd'
+        key = rc.write 'abcd'
+        assert { rc.read(key) == 'abcd' }
+      end
+    end
+  end
+end

data/spec/transit/round_trip_spec.rb

@@ -0,0 +1,172 @@
+# Copyright 2014 Cognitect. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS-IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'spec_helper'
+
+def nan?(obj)
+  obj.respond_to?(:nan?) and obj.nan?
+end
+
+def round_trip(obj, type, opts={})
+  obj_before = obj
+
+  io = StringIO.new('', 'w+')
+  writer = Transit::Writer.new(type, io, :handlers => opts[:write_handlers])
+  writer.write(obj)
+
+  # ensure that we don't modify the object being written
+  if nan?(obj_before)
+    assert { obj.nan? }
+  else
+    assert { obj == obj_before }
+  end
+  reader = Transit::Reader.new(type, StringIO.new(io.string), :handlers => opts[:read_handlers])
+  reader.read
+end
+
+def assert_equal_times(actual,expected)
+  return false unless expected.is_a?(Date) || expected.is_a?(Time) || expected.is_a?(DateTime)
+  assert { Transit::DateTimeUtil.to_millis(actual) == Transit::DateTimeUtil.to_millis(expected) }
+  assert { actual.zone == expected.zone }
+end
+
+def assert_nan(actual,expected)
+  return false unless nan?(expected)
+  expect(actual.respond_to?(:nan?)).to eq(true)
+  expect(actual.nan?).to eq(true)
+end
+
+def validate(expected, actual)
+  assert_equal_times(actual, expected) || assert_nan(actual, expected) || (expect(actual).to eq(expected))
+end
+
+def round_trips(label, obj, type, opts={})
+  expected = opts[:expected] || obj
+
+  it "round trips #{label} at top level", :focus => !!opts[:focus], :pending => opts[:pending] do
+    validate(expected, round_trip(obj, type, opts))
+  end
+
+  it "round trips #{label} as a map key", :focus => !!opts[:focus], :pending => opts[:pending] do
+    validate(expected, round_trip({obj => 0}, type, opts).keys.first)
+  end
+
+  it "round trips #{label} as a map value", :focus => !!opts[:focus], :pending => opts[:pending] do
+    validate(expected, round_trip({a: obj}, type, opts).values.first)
+  end
+
+  it "round trips #{label} as an array value", :focus => !!opts[:focus], :pending => opts[:pending] do
+    validate(expected, round_trip([obj], type, opts).first)
+  end
+end
+
+module Transit
+  PhoneNumber = Struct.new(:area, :prefix, :suffix)
+  def PhoneNumber.parse(p)
+    area, prefix, suffix = p.split(".")
+    PhoneNumber.new(area, prefix, suffix)
+  end
+
+  class PhoneNumberHandler
+    def tag(_) "P" end
+    def rep(p) "#{p.area}.#{p.prefix}.#{p.suffix}" end
+    def string_rep(p) rep(p) end
+  end
+
+  class PhoneNumberReadHandler
+    def from_rep(v) PhoneNumber.parse(v) end
+  end
+
+  class PersonReadHandler
+    def from_rep(v)
+      Person.new(v[:first_name],v[:last_name],v[:birthdate])
+    end
+  end
+
+  shared_examples "round trips" do |type|
+    round_trips("nil", nil, type)
+    round_trips("a keyword", random_symbol, type)
+    round_trips("a string", random_string, type)
+    round_trips("a string starting with ~", "~#{random_string}", type)
+    round_trips("a string starting with ^", "^#{random_string}", type)
+    round_trips("a string starting with `", "`#{random_string}", type)
+    round_trips("true", true, type)
+    round_trips("false", false, type)
+    round_trips("a small int", 1, type)
+    round_trips("a big int", 123456789012345, type)
+    round_trips("a very big int", 123456789012345679012345678890, type)
+    round_trips("a float", 1234.56, type)
+    round_trips("NaN", Float::NAN, type)
+    round_trips("Infinity", Float::INFINITY, type)
+    round_trips("-Infinity", -Float::INFINITY, type)
+    round_trips("a bigdec", BigDecimal.new("123.45"), type)
+    round_trips("an instant (DateTime local)", DateTime.new(2014,1,2,3,4,5, "-5"), type,
+                :expected => DateTime.new(2014,1,2, (3+5) ,4,5, "+00:00"))
+    round_trips("an instant (DateTime gmt)", DateTime.new(2014,1,2,3,4,5), type)
+    round_trips("an instant (Time local)", Time.new(2014,1,2,3,4,5, "-05:00"), type,
+                :expected => DateTime.new(2014,1,2, (3+5) ,4,5, "+00:00"))
+    round_trips("an instant (Time gmt)", Time.new(2014,1,2,3,4,5, "+00:00"), type,
+                :expected => DateTime.new(2014,1,2,3,4,5, "+00:00"))
+    round_trips("a Date", Date.new(2014,1,2), type, :expected => DateTime.new(2014,1,2))
+    round_trips("a uuid", UUID.new, type)
+    round_trips("a link", Link.new(Addressable::URI.parse("http://example.org/search"), "search"), type)
+    round_trips("a link", Link.new(Addressable::URI.parse("http://example.org/search"), "search", nil, "image"), type)
+    round_trips("a link with string uri", Link.new("http://example.org/search", "search", nil, "image"), type)
+    round_trips("a uri (url)", Addressable::URI.parse("http://example.com"), type)
+    round_trips("a uri (file)", Addressable::URI.parse("file:///path/to/file.txt"), type)
+    round_trips("a bytearray", ByteArray.new(random_string(50)), type)
+    round_trips("a Transit::Symbol", Transit::Symbol.new(random_string), type)
+    round_trips("a hash w/ stringable keys", {"this" => "~hash", "1" => 2}, type)
+    round_trips("a set", Set.new([1,2,3]), type)
+    round_trips("a set of sets", Set.new([Set.new([1,2]), Set.new([3,4])]), type)
+    round_trips("an array", [1,2,3], type)
+    round_trips("a char", TaggedValue.new("c", "x"), type, :expected => "x")
+    round_trips("a list", TaggedValue.new("list", [1,2,3]), type, :expected => [1,2,3])
+    round_trips("an array of maps w/ cacheable keys", [{"this" => "a"},{"this" => "b"}], type)
+
+    round_trips("edge case chars", %w[` ~ ^ #], type)
+
+    round_trips("an extension scalar", PhoneNumber.new("555","867","5309"), type,
+                :write_handlers => {PhoneNumber => PhoneNumberHandler.new},
+                :read_handlers  => {"P" => PhoneNumberReadHandler.new})
+    round_trips("an extension struct", Person.new("First","Last",:today), type,
+                :write_handlers => {Person => PersonHandler.new},
+                :read_handlers  => {"person" => PersonReadHandler.new})
+    round_trips("a hash with simple values", {'a' => 1, 'b' => 2, 'name' => 'russ'}, type)
+    round_trips("a hash with Transit::Symbols", {Transit::Symbol.new("foo") => Transit::Symbol.new("bar")}, type)
+    round_trips("a hash with 53 bit ints",  {2**53-1 => 2**53-2}, type)
+    round_trips("a hash with 54 bit ints",  {2**53   => 2**53+1}, type)
+    round_trips("a map with composite keys", {{a: :b} => {c: :d}}, type)
+    round_trips("a TaggedValue", TaggedValue.new("unrecognized",:value), type)
+    round_trips("an unrecognized hash encoding", {"~#unrecognized" => :value}, type)
+    round_trips("an unrecognized string encoding", "~Xunrecognized", type)
+
+    round_trips("a nested structure (map on top)", {a: [1, [{b: "~c"}]]}, type)
+    round_trips("a nested structure (array on top)", [37, {a: [1, [{b: "~c"}]]}], type)
+    round_trips("a map that looks like transit data", [{"~#set"=>[1,2,3]},{"~#set"=>[4,5,6]}], type)
+    round_trips("a ratio of big value", [{"~#ratio"=>["~n36893488147419103231","~n73786976294838206463"]}], type)
+  end
+
+  describe "Transit using json" do
+    include_examples "round trips", :json
+  end
+
+  describe "Transit using json_verbose" do
+    include_examples "round trips", :json_verbose
+  end
+
+  describe "Transit using msgpack" do
+    include_examples "round trips", :msgpack
+  end
+end

data/spec/transit/transit_types_spec.rb

@@ -0,0 +1,144 @@
+# -*- coding: utf-8 -*-
+# Copyright 2014 Cognitect. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS-IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'spec_helper'
+
+module Transit
+  describe Transit::Symbol do
+    it 'can be made from a symbol' do
+      500.times do
+        sym = random_symbol
+        assert { Transit::Symbol.new(sym).to_sym == sym }
+      end
+    end
+
+    it 'can be made from a string' do
+      500.times do
+        str = random_string
+        assert { Transit::Symbol.new(str).to_sym == str.to_sym }
+      end
+    end
+
+    it 'is equal to another rendition of itself' do
+      500.times do
+        sym = random_symbol
+        assert { Transit::Symbol.new(sym) == Transit::Symbol.new(sym)}
+      end
+    end
+
+    it 'behaves as a hash key' do
+      keys = Set.new(Array.new(1000).map {|x| random_symbol})
+
+      test_hash = {}
+      keys.each_with_index {|k, i| test_hash[Transit::Symbol.new(k)] = i}
+
+      keys.each_with_index do |k, i|
+        new_key = Transit::Symbol.new(k)
+        value = test_hash[new_key]
+        assert { value == i }
+      end
+    end
+
+    it "provides namespace" do
+      assert { Transit::Symbol.new("foo/bar").namespace == "foo" }
+      assert { Transit::Symbol.new("foo").namespace == nil }
+    end
+
+    it "provides name" do
+      assert { Transit::Symbol.new("foo").name == "foo" }
+      assert { Transit::Symbol.new("foo/bar").name == "bar" }
+    end
+
+    it "special cases '/'" do
+      assert { Transit::Symbol.new("/").name == "/" }
+      assert { Transit::Symbol.new("/").namespace == nil }
+    end
+  end
+
+  describe UUID do
+    it 'round trips strings' do
+      10.times do
+        uuid = UUID.random
+        assert { UUID.new(uuid.to_s) == uuid }
+      end
+    end
+
+    it 'round trips ints' do
+      10.times do
+        uuid = UUID.random
+        assert { UUID.new(uuid.most_significant_bits, uuid.least_significant_bits) == uuid }
+      end
+    end
+  end
+
+  describe Link do
+    let(:href) { Addressable::URI.parse("http://example.org/search") }
+    let(:string_href) { "http://example.org/search" }
+    let(:rel) { "search" }
+    let(:prompt) { "Enter search string" }
+    let(:name) { "this is my name" }
+
+    it 'can be made from some given arugments' do
+      link = Link.new(href, rel)
+      assert { link.href == href }
+      assert { link.rel == rel }
+      assert { link.prompt == nil }
+      assert { link.name == nil }
+      assert { link.render == nil }
+    end
+
+    it 'can be made from all 5 given correct arguments' do
+      link = Link.new(href, rel, name, "Image", prompt)
+      assert { link.href == href }
+      assert { link.rel == rel }
+      assert { link.name == name }
+      assert { link.render == "image" }
+      assert { link.prompt == prompt }
+    end
+
+    it 'can be made with uri in string' do
+      link = Link.new(string_href, rel)
+      assert { link.href == Addressable::URI.parse(string_href) }
+    end
+
+    it 'raises exception if href and rel are not given' do
+      assert { rescuing { Link.new }.is_a? ArgumentError }
+      assert { rescuing { Link.new("foo") }.is_a? ArgumentError }
+    end
+
+    it 'raises exception if render is not a valid value (link|image)' do
+      assert { rescuing { Link.new(href, rel, nil, "document") }.is_a? ArgumentError }
+    end
+
+    it 'leaves the input map alone' do
+      input = {"href" => "http://example.com", "rel" => "???", "render" => "LINK"}
+      Link.new(input)
+      assert { input["href"] == "http://example.com" }
+      assert { input["render"] == "LINK" }
+    end
+
+    it 'produces a frozen map' do
+      assert { Link.new("/path", "the-rel").to_h.frozen? }
+    end
+  end
+
+  describe ByteArray do
+    it 'uses the default_external encoding for to_s' do
+      src = ByteArray.new("foo".force_encoding("ascii")).to_base64
+      target = ByteArray.from_base64(src)
+      assert { target.to_s.encoding == Encoding.default_external }
+    end
+  end
+end