lutaml-model 0.3.24 → 0.3.25

data/spec/lutaml/model/type/hash_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Type::Hash do
+  describe ".cast" do
+    it "returns nil for nil input" do
+      expect(described_class.cast(nil)).to be_nil
+    end
+
+    it "returns text content from hash with only text key" do
+      hash = { "text" => "content" }
+      expect(described_class.cast(hash)).to eq "content"
+    end
+
+    it "normalizes MappingHash to regular Hash" do
+      mapping_hash = Lutaml::Model::MappingHash.new
+      mapping_hash["key"] = "value"
+      expect(described_class.cast(mapping_hash)).to eq({ "key" => "value" })
+    end
+
+    it "filters out text keys from nested hashes" do
+      hash = {
+        "key1" => {
+          "text" => "content1",
+          "other" => "value1",
+        },
+        "key2" => {
+          "text" => "content2",
+          "other" => "value2",
+        },
+      }
+      expected = {
+        "key1" => { "other" => "value1" },
+        "key2" => { "other" => "value2" },
+      }
+      expect(described_class.cast(hash)).to eq expected
+    end
+
+    it "preserves non-hash values" do
+      input = {
+        "string" => "value",
+        "number" => 42,
+        "array" => [1, 2, 3],
+      }
+      expect(described_class.cast(input)).to eq input
+    end
+  end
+
+  describe ".serialize" do
+    it "returns nil for nil input" do
+      expect(described_class.serialize(nil)).to be_nil
+    end
+
+    it "converts hash to hash" do
+      hash = { "key" => "value" }
+      expect(described_class.serialize(hash)).to eq hash
+    end
+
+    it "converts arbitrary object responding to to_h" do
+      obj = double(to_h: { "key" => "value" })
+      expect(described_class.serialize(obj)).to eq({ "key" => "value" })
+    end
+  end
+end

data/spec/lutaml/model/type/integer_spec.rb

@@ -0,0 +1,145 @@
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Type::Integer do
+  describe ".cast" do
+    subject(:cast) { described_class.cast(value) }
+
+    context "with nil value" do
+      let(:value) { nil }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with integer" do
+      let(:value) { 123 }
+
+      it { is_expected.to eq(123) }
+    end
+
+    context "with integer string" do
+      let(:value) { "123" }
+
+      it { is_expected.to eq(123) }
+    end
+
+    context "with negative integer string" do
+      let(:value) { "-123" }
+
+      it { is_expected.to eq(-123) }
+    end
+
+    context "with float" do
+      let(:value) { 123.45 }
+
+      it { is_expected.to eq(123) }
+    end
+
+    context "with float string" do
+      let(:value) { "123.45" }
+
+      it { is_expected.to eq(123) }
+    end
+
+    context "with exponential notation" do
+      let(:value) { "1.23e2" }
+
+      it { is_expected.to eq(123) }
+    end
+
+    context "with negative exponential notation" do
+      let(:value) { "-1.23e2" }
+
+      it { is_expected.to eq(-123) }
+    end
+
+    context "with string containing a leading zero represents octal" do
+      let(:value) { "0123" }
+
+      it { is_expected.to eq(83) }
+    end
+
+    context "with plus sign" do
+      let(:value) { "+123" }
+
+      it { is_expected.to eq(123) }
+    end
+
+    context "with whitespace" do
+      let(:value) { " 123 " }
+
+      it { is_expected.to eq(123) }
+    end
+
+    context "with boolean true" do
+      let(:value) { true }
+
+      it { is_expected.to eq(1) }
+    end
+
+    context "with boolean false" do
+      let(:value) { false }
+
+      it { is_expected.to eq(0) }
+    end
+
+    context "with invalid string" do
+      let(:value) { "not an integer" }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with very large integer" do
+      let(:max_value) { ((2**((0.size * 8) - 2)) - 1) }
+      let(:value) { max_value.to_s }
+
+      xit { is_expected.to eq(max_value) }
+    end
+
+    context "with very small integer" do
+      let(:min_value) { -(2**((0.size * 8) - 2)) }
+      let(:value) { min_value.to_s }
+
+      it { is_expected.to eq(min_value) }
+    end
+  end
+
+  describe ".serialize" do
+    subject(:serialize) { described_class.serialize(value) }
+
+    context "with nil value" do
+      let(:value) { nil }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with positive integer" do
+      let(:value) { 123 }
+
+      it { is_expected.to eq(123) }
+    end
+
+    context "with negative integer" do
+      let(:value) { -123 }
+
+      it { is_expected.to eq(-123) }
+    end
+
+    context "with zero" do
+      let(:value) { 0 }
+
+      it { is_expected.to eq(0) }
+    end
+
+    context "with maximum integer" do
+      let(:value) { 9223372036854775807 }
+
+      it { is_expected.to eq(9223372036854775807) }
+    end
+
+    context "with minimum integer" do
+      let(:value) { -9223372036854775808 }
+
+      it { is_expected.to eq(-9223372036854775808) }
+    end
+  end
+end

data/spec/lutaml/model/type/string_spec.rb

@@ -0,0 +1,150 @@
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Type::String do
+  describe ".cast" do
+    subject(:cast) { described_class.cast(value) }
+
+    context "with nil value" do
+      let(:value) { nil }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with string value" do
+      let(:value) { "test" }
+
+      it { is_expected.to eq("test") }
+    end
+
+    context "with symbol" do
+      let(:value) { :symbol }
+
+      it { is_expected.to eq("symbol") }
+    end
+
+    context "with integer" do
+      let(:value) { 123 }
+
+      it { is_expected.to eq("123") }
+    end
+
+    context "with float" do
+      let(:value) { 123.45 }
+
+      it { is_expected.to eq("123.45") }
+    end
+
+    context "with true" do
+      let(:value) { true }
+
+      it { is_expected.to eq("true") }
+    end
+
+    context "with false" do
+      let(:value) { false }
+
+      it { is_expected.to eq("false") }
+    end
+
+    context "with Date object" do
+      let(:value) { Date.new(2024, 1, 1) }
+
+      it { is_expected.to eq("2024-01-01") }
+    end
+
+    context "with Time object" do
+      let(:value) { Time.new(2024, 1, 1, 12, 0, 0, "+00:00") }
+
+      it { is_expected.to match(/\A2024-01-01 12:00:00/) }
+    end
+
+    context "with array" do
+      let(:value) { [1, 2, 3] }
+
+      it { is_expected.to eq("[1, 2, 3]") }
+    end
+
+    context "with hash" do
+      let(:value) { { a: 1, b: 2 } }
+      let(:expected_value) do
+        if RUBY_VERSION < "3.4.0"
+          "{:a=>1, :b=>2}"
+        else
+          "{a: 1, b: 2}"
+        end
+      end
+
+      it { is_expected.to eq(expected_value) }
+    end
+
+    context "with object responding to to_s" do
+      let(:value) do
+        Class.new do
+          def to_s
+            "custom string"
+          end
+        end.new
+      end
+
+      it { is_expected.to eq("custom string") }
+    end
+
+    context "with empty string" do
+      let(:value) { "" }
+
+      it { is_expected.to eq("") }
+    end
+
+    context "with whitespace string" do
+      let(:value) { "  \t\n  " }
+
+      it { is_expected.to eq("  \t\n  ") }
+    end
+  end
+
+  describe ".serialize" do
+    subject(:serialize) { described_class.serialize(value) }
+
+    context "with nil value" do
+      let(:value) { nil }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with string value" do
+      let(:value) { "test" }
+
+      it { is_expected.to eq("test") }
+    end
+
+    context "with empty string" do
+      let(:value) { "" }
+
+      it { is_expected.to eq("") }
+    end
+
+    context "with whitespace string" do
+      let(:value) { "  \t\n  " }
+
+      it { is_expected.to eq("  \t\n  ") }
+    end
+
+    context "with string containing special characters" do
+      let(:value) { "test\u0000test" }
+
+      it { is_expected.to eq("test\u0000test") }
+    end
+
+    context "with unicode characters" do
+      let(:value) { "こんにちは" }
+
+      it { is_expected.to eq("こんにちは") }
+    end
+
+    context "with emoji" do
+      let(:value) { "Hello 👋" }
+
+      it { is_expected.to eq("Hello 👋") }
+    end
+  end
+end

data/spec/lutaml/model/type/time_spec.rb

@@ -0,0 +1,142 @@
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Type::Time do
+  describe ".cast" do
+    subject(:cast) { described_class.cast(value) }
+
+    context "with nil value" do
+      let(:value) { nil }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with valid Time string" do
+      let(:value) { "2024-01-01T12:00:00Z" }
+
+      it "parses with UTC offset" do
+        expect(cast.utc_offset).to eq(0)
+        expect(cast.strftime("%:z")).to eq("+00:00")
+      end
+    end
+
+    context "with positive timezone offset" do
+      let(:value) { "2024-01-01T12:00:00+08:00" }
+
+      it "retains the positive offset" do
+        expect(cast.utc_offset).to eq(8 * 3600)
+        expect(cast.strftime("%:z")).to eq("+08:00")
+      end
+    end
+
+    context "with negative timezone offset" do
+      let(:value) { "2024-01-01T12:00:00-05:00" }
+
+      it "retains the negative offset" do
+        expect(cast.utc_offset).to eq(-5 * 3600)
+        expect(cast.strftime("%:z")).to eq("-05:00")
+      end
+    end
+
+    context "with fractional offset" do
+      let(:value) { "2024-01-01T12:00:00+05:30" }
+
+      it "retains the fractional offset" do
+        expect(cast.utc_offset).to eq((5 * 3600) + (30 * 60))
+        expect(cast.strftime("%:z")).to eq("+05:30")
+      end
+    end
+
+    context "with DateTime object" do
+      let(:value) { DateTime.new(2024, 1, 1, 12, 0, 0, "+08:00") }
+
+      it "preserves the offset" do
+        expect(cast.utc_offset).to eq(8 * 3600)
+        expect(cast.strftime("%:z")).to eq("+08:00")
+      end
+    end
+
+    context "with Time object" do
+      let(:value) { Time.new(2024, 1, 1, 12, 0, 0, "+08:00") }
+
+      it "preserves the offset" do
+        expect(cast.utc_offset).to eq(8 * 3600)
+        expect(cast.strftime("%:z")).to eq("+08:00")
+      end
+    end
+
+    context "with invalid Time string" do
+      let(:value) { "not a time" }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with microsecond precision" do
+      let(:value) { "2024-01-01T12:00:00.123456+08:00" }
+
+      it "retains microsecond precision" do
+        expect(cast.usec).to eq(123456)
+        expect(cast.strftime("%:z")).to eq("+08:00")
+      end
+    end
+  end
+
+  describe ".serialize" do
+    subject(:serialize) { described_class.serialize(value) }
+
+    context "with nil value" do
+      let(:value) { nil }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with UTC Time" do
+      let(:value) { Time.new(2024, 1, 1, 12, 0, 0, "+00:00") }
+
+      it "serializes with +00:00 offset" do
+        expect(serialize).to eq("2024-01-01T12:00:00+00:00")
+      end
+    end
+
+    context "with positive offset" do
+      let(:value) { Time.new(2024, 1, 1, 12, 0, 0, "+08:00") }
+
+      it "retains positive offset in serialized form" do
+        expect(serialize).to eq("2024-01-01T12:00:00+08:00")
+      end
+    end
+
+    context "with negative offset" do
+      let(:value) { Time.new(2024, 1, 1, 12, 0, 0, "-05:00") }
+
+      it "retains negative offset in serialized form" do
+        expect(serialize).to eq("2024-01-01T12:00:00-05:00")
+      end
+    end
+
+    context "with fractional offset" do
+      let(:value) { Time.new(2024, 1, 1, 12, 0, 0, "+05:30") }
+
+      it "retains fractional offset in serialized form" do
+        expect(serialize).to eq("2024-01-01T12:00:00+05:30")
+      end
+    end
+
+    context "with fractional seconds" do
+      let(:value) { Time.new(2024, 1, 1, 12, 0, 0.5, "+08:00") }
+
+      xit "retains both fractional seconds and offset" do
+        expect(serialize).to eq("2024-01-01T12:00:00.500+08:00")
+      end
+    end
+
+    context "with microsecond precision" do
+      let(:value) { Time.at(Time.new(2024, 1, 1, 12).to_i, 123456, :usec) }
+
+      before { value.localtime("+08:00") }
+
+      xit "retains microsecond precision and offset" do
+        expect(serialize).to eq("2024-01-01T12:00:00.123456+08:00")
+      end
+    end
+  end
+end

data/spec/lutaml/model/type/time_without_date_spec.rb

@@ -0,0 +1,125 @@
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Type::TimeWithoutDate do
+  describe ".cast" do
+    subject(:cast) { described_class.cast(value) }
+
+    context "with nil value" do
+      let(:value) { nil }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with time string" do
+      let(:value) { "13:45:30" }
+
+      it "parses time correctly" do
+        expect(cast.hour).to eq(13)
+        expect(cast.min).to eq(45)
+        expect(cast.sec).to eq(30)
+      end
+    end
+
+    context "with time string with milliseconds" do
+      let(:value) { "13:45:30.500" }
+
+      it "parses time with milliseconds" do
+        expect(cast.hour).to eq(13)
+        expect(cast.min).to eq(45)
+        expect(cast.sec).to eq(30)
+        expect(cast.nsec).to eq(500_000_000)
+      end
+    end
+
+    context "with Time object" do
+      let(:value) { Time.new(2024, 1, 1, 13, 45, 30) }
+
+      it "extracts time components" do
+        expect(cast.hour).to eq(13)
+        expect(cast.min).to eq(45)
+        expect(cast.sec).to eq(30)
+      end
+    end
+
+    context "with DateTime object" do
+      let(:value) { DateTime.new(2024, 1, 1, 13, 45, 30) }
+
+      it "extracts time components" do
+        expect(cast.hour).to eq(13)
+        expect(cast.min).to eq(45)
+        expect(cast.sec).to eq(30)
+      end
+    end
+
+    context "with invalid time string" do
+      let(:value) { "not a time" }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with invalid hours" do
+      let(:value) { "24:00:00" }
+
+      xit { is_expected.to be_nil }
+    end
+
+    context "with invalid minutes" do
+      let(:value) { "12:60:00" }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with invalid seconds" do
+      let(:value) { "12:00:61" }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with microsecond precision" do
+      let(:value) { "13:45:30.123456" }
+
+      it "retains microsecond precision" do
+        expect(cast.hour).to eq(13)
+        expect(cast.min).to eq(45)
+        expect(cast.sec).to eq(30)
+        expect(cast.usec).to eq(123456)
+      end
+    end
+  end
+
+  describe ".serialize" do
+    subject(:serialize) { described_class.serialize(value) }
+
+    context "with nil value" do
+      let(:value) { nil }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with Time object" do
+      let(:value) { Time.new(2024, 1, 1, 13, 45, 30) }
+
+      it { is_expected.to eq("13:45:30") }
+    end
+
+    context "with single-digit values" do
+      let(:value) { Time.new(2024, 1, 1, 9, 5, 3) }
+
+      it "zero-pads values" do
+        expect(serialize).to eq("09:05:03")
+      end
+    end
+
+    context "with double-digit values" do
+      let(:value) { Time.new(2024, 1, 1, 13, 45, 30) }
+
+      it { is_expected.to eq("13:45:30") }
+    end
+
+    context "with zero values" do
+      let(:value) { Time.new(2024, 1, 1, 0, 0, 0) }
+
+      it { is_expected.to eq("00:00:00") }
+    end
+  end
+end