lutaml-model 0.6.1 → 0.6.2

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

@@ -17,31 +17,44 @@ RSpec.describe Lutaml::Model::Type::Hash do
       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
+    context "with nested hashes" do
+      let(:input) do
+        {
+          "key1" => {
+            "text" => "content1",
+            "other" => "value1",
+          },
+          "key2" => {
+            "text" => "content2",
+            "other" => "value2",
+          },
+        }
+      end
+
+      let(:expected_hash) do
+        {
+          "key1" => { "other" => "value1" },
+          "key2" => { "other" => "value2" },
+        }
+      end
+
+      it "filters out text keys from nested hashes" do
+        expect(described_class.cast(input)).to eq(expected_hash)
+      end
+    end
+
+    context "with non-hash values" do
+      let(:input) do
+        {
+          "string" => "value",
+          "number" => 42,
+          "array" => [1, 2, 3],
+        }
+      end
+
+      it "preserves non-hash values" do
+        expect(described_class.cast(input)).to eq input
+      end
     end
   end
 
@@ -56,7 +69,7 @@ RSpec.describe Lutaml::Model::Type::Hash do
     end
 
     it "converts arbitrary object responding to to_h" do
-      obj = double(to_h: { "key" => "value" })
+      obj = instance_double(Hash, to_h: { "key" => "value" })
       expect(described_class.serialize(obj)).to eq({ "key" => "value" })
     end
   end

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

@@ -89,10 +89,10 @@ RSpec.describe Lutaml::Model::Type::Integer do
     end
 
     context "with very large integer" do
-      let(:max_value) { ((2**((0.size * 8) - 2)) - 1) }
+      let(:max_value) { ((2**((0.size * 8) - 2))) }
       let(:value) { max_value.to_s }
 
-      xit { is_expected.to eq(max_value) }
+      it { is_expected.to eq(max_value) }
     end
 
     context "with very small integer" do

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

@@ -96,12 +96,6 @@ RSpec.describe Lutaml::Model::Type::TimeWithoutDate do
       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) }
 

data/spec/lutaml/model/type_spec.rb

@@ -191,12 +191,7 @@ RSpec.describe Lutaml::Model::Type do
 
       context "when BigDecimal is not available" do
         before do
-          Object.send(:remove_const, :BigDecimal) if defined?(BigDecimal)
-          $LOADED_FEATURES.delete_if { |path| path.include?("bigdecimal") }
-        end
-
-        after do
-          require "bigdecimal"
+          hide_const("BigDecimal") if defined?(BigDecimal)
         end
 
         let(:decimal_class) { described_class.lookup(:decimal) }
@@ -277,8 +272,8 @@ RSpec.describe Lutaml::Model::Type do
     end
 
     describe "Serialization" do
-      it "correctly serializes to XML" do
-        expected_xml = <<~XML
+      let(:xml) do
+        <<~XML
           <test>
             <string_symbol>test</string_symbol>
             <string_class>test</string_class>
@@ -294,28 +289,13 @@ RSpec.describe Lutaml::Model::Type do
             </hash>
           </test>
         XML
+      end
 
-        expect(test_instance.to_xml).to be_equivalent_to(expected_xml)
+      it "correctly serializes to XML" do
+        expect(test_instance.to_xml).to be_equivalent_to(xml)
       end
 
       it "correctly deserializes from XML" do
-        xml = <<~XML
-          <test>
-            <string_symbol>test</string_symbol>
-            <string_class>test</string_class>
-            <integer>123</integer>
-            <float>123.45</float>
-            <date>2024-01-01</date>
-            <time>12:00:00</time>
-            <time_without_date>10:06:15</time_without_date>
-            <date_time>2024-01-01T12:00:00</date_time>
-            <boolean>true</boolean>
-            <hash>
-              <key>value</key>
-            </hash>
-          </test>
-        XML
-
         deserialized = TypeTestModel.from_xml(xml)
         expect(deserialized.string_symbol).to eq("test")
         expect(deserialized.string_class).to eq("test")

data/spec/lutaml/model/utils_spec.rb

@@ -69,43 +69,38 @@ RSpec.describe Lutaml::Model::Utils do
     let(:duplicate_array) { utils.deep_dup(original_array) }
 
     it "creates deep duplicate of hash" do
-      expect(original_hash).to eq(duplicate_hash)
-      expect(original_hash.object_id).not_to eq(duplicate_hash.object_id)
-
-      expect(original_hash[:one]).to eq(duplicate_hash[:one])
-      expect(original_hash[:one].object_id).not_to eq(duplicate_hash[:one].object_id)
-
-      expect(original_hash[:one][:one_one]).to eq(duplicate_hash[:one][:one_one])
-      expect(original_hash[:one][:one_one].object_id).not_to eq(duplicate_hash[:one][:one_one].object_id)
-
-      expect(original_hash[:one][:one_one][:one_one1]).to eq(duplicate_hash[:one][:one_one][:one_one1])
-      expect(original_hash[:one][:one_one][:one_one1].object_id).not_to eq(duplicate_hash[:one][:one_one][:one_one1].object_id)
-
-      # this is a symbol so the object_id will be same
-      expect(original_hash[:one][:one_one][:one_one2]).to eq(duplicate_hash[:one][:one_one][:one_one2])
-
-      expect(original_hash[:one][:one_two]).to eq(duplicate_hash[:one][:one_two])
-      expect(original_hash[:one][:one_two].object_id).not_to eq(duplicate_hash[:one][:one_two].object_id)
+      expect(compare_duplicate(original_hash, duplicate_hash)).to be_truthy
     end
 
-    it "creates deep duplicate of array" do
-      expect(original_array).to eq(duplicate_array)
-      expect(original_array.object_id).not_to eq(duplicate_array.object_id)
+    it "creates a deep duplicate of the array" do
+      expect(compare_duplicate(original_array, duplicate_array)).to be_truthy
+    end
 
-      expect(original_array[0]).to eq(duplicate_array[0])
-      expect(original_array[0].object_id).not_to eq(duplicate_array[0].object_id)
+    def compare_duplicate(original, duplicate)
+      return false unless original == duplicate
+      return false if !primitive?(original) && original.equal?(duplicate)
 
-      expect(original_array[1][0]).to eq(duplicate_array[1][0])
-      expect(original_array[1][0].object_id).not_to eq(duplicate_array[1][0].object_id)
+      case original
+      when Array then compare_array(original, duplicate)
+      when Hash then compare_hash(original, duplicate)
+      else true
+      end
+    end
 
-      expect(original_array[1][1][0]).to eq(duplicate_array[1][1][0])
-      expect(original_array[1][1][0].object_id).not_to eq(duplicate_array[1][1][0].object_id)
+    def compare_array(original, duplicate)
+      original.each_with_index.all? do |el, i|
+        compare_duplicate(el, duplicate[i])
+      end
+    end
 
-      expect(original_array[1][1][1]).to eq(duplicate_array[1][1][1])
-      expect(original_array[1][1][1].object_id).not_to eq(duplicate_array[1][1][1].object_id)
+    def compare_hash(original, duplicate)
+      original.keys.all? do |key|
+        compare_duplicate(original[key], duplicate[key])
+      end
+    end
 
-      expect(original_array[1][2]).to eq(duplicate_array[1][2])
-      expect(original_array[1][2].object_id).not_to eq(duplicate_array[1][2].object_id)
+    def primitive?(value)
+      [Symbol, NilClass, TrueClass, FalseClass].include?(value.class)
     end
   end
 end

data/spec/lutaml/model/validation_spec.rb

@@ -3,12 +3,15 @@
 require "spec_helper"
 
 RSpec.describe Lutaml::Model::Validation do
-  class ValidationTestClass < Lutaml::Model::Serializable
-    attribute :name, :string
-    attribute :age, :integer
-    attribute :email, :string, values: ["test@example.com", "user@example.com"]
-    attribute :tags, :string, collection: true
-    attribute :role, :string, collection: 1..3
+  before do
+    stub_const("ValidationTestClass", Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :age, :integer
+      attribute :email, :string,
+                values: ["test@example.com", "user@example.com"]
+      attribute :tags, :string, collection: true
+      attribute :role, :string, collection: 1..3
+    end)
   end
 
   let(:valid_instance) do

data/spec/lutaml/model/xml_adapter/oga_adapter_spec.rb

@@ -13,7 +13,7 @@ RSpec.describe Lutaml::Model::XmlAdapter::OgaAdapter do
 
   let(:document) { described_class.parse(xml_string) }
 
-  context "parsing XML with namespaces" do
+  context "when parsing XML with namespaces" do
     let(:child) { document.root.children.first }
 
     it "parses the root element with default namespace" do
@@ -37,7 +37,7 @@ RSpec.describe Lutaml::Model::XmlAdapter::OgaAdapter do
     end
   end
 
-  context "generating XML with namespaces" do
+  context "when generating XML with namespaces" do
     it "generates XML with namespaces correctly" do
       xml_output = document.root.to_xml
       parsed_output = Moxml::Adapter::Oga.parse(xml_output)

data/spec/lutaml/model/xml_adapter/ox_adapter_spec.rb

@@ -14,7 +14,7 @@ RSpec.describe Lutaml::Model::XmlAdapter::OxAdapter do
 
   let(:document) { described_class.parse(xml_string) }
 
-  context "parsing XML with namespaces" do
+  context "when parsing XML with namespaces" do
     it "parses the root element with default namespace" do
       expect(document.root.name).to eq("root")
       expect(document.root.namespace.uri).to eq("http://example.com/default")
@@ -42,7 +42,7 @@ RSpec.describe Lutaml::Model::XmlAdapter::OxAdapter do
     end
   end
 
-  context "generating XML with namespaces" do
+  context "when generating XML with namespaces" do
     it "generates XML with namespaces correctly" do
       xml_output = document.to_xml
       parsed_output = Ox.parse(xml_output)