lutaml-model 0.5.4 → 0.6.0

data/spec/lutaml/model/schema/xml_compiler_spec.rb

@@ -1,7 +1,6 @@
 require "spec_helper"
 require "lutaml/model/schema"
 require "lutaml/xsd"
-require "tmpdir"
 
 RSpec.describe Lutaml::Model::Schema::XmlCompiler do
   describe ".to_models" do
@@ -25,8 +24,8 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
       end
 
       Dir.mktmpdir do |dir|
-        it "generates the models, requires them, and tests them with valid and invalid xml" do
-          described_class.to_models(File.read("spec/fixtures/xml/test_schema.xsd"), output_dir: dir)
+        it "creates the model files, requires them, and tests them with valid and invalid xml" do
+          described_class.to_models(File.read("spec/fixtures/xml/test_schema.xsd"), output_dir: dir, create_files: true)
           expect(File).to exist("#{dir}/ct_math_test.rb")
           expect(File).to exist("#{dir}/st_integer255.rb")
           expect(File).to exist("#{dir}/long.rb")
@@ -38,20 +37,25 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
       end
     end
 
-    context "when processing examples from classes generated by valid xml schema" do
+    context "when processing examples from classes/files generated by valid xml schema" do
       Dir.mktmpdir do |dir|
         before do
           described_class.to_models(
             File.read("spec/fixtures/xml/math_document_schema.xsd"),
             output_dir: dir,
+            create_files: true,
           )
           require_relative "#{dir}/math_document"
         end
 
-        let(:valid_example) { File.read("spec/fixtures/xml/valid_math_document.xml") }
-        let(:invalid_example) { File.read("spec/fixtures/xml/invalid_math_document.xml") }
+        let(:valid_example) do
+          File.read("spec/fixtures/xml/valid_math_document.xml")
+        end
+        let(:invalid_example) do
+          File.read("spec/fixtures/xml/invalid_math_document.xml")
+        end
 
-        it "does not raise error with valid example" do
+        it "does not raise error with valid example and creates files" do
           expect(defined?(MathDocument)).to eq("constant")
           parsed = MathDocument.from_xml(valid_example)
           expect(parsed.title).to eql("Example Title")
@@ -65,6 +69,100 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
         end
       end
     end
+
+    context "when processing example from lutaml-model#260" do
+      Dir.mktmpdir do |dir|
+        before do
+          described_class.to_models(
+            File.read("spec/fixtures/xml/address_example_260.xsd"),
+            output_dir: dir,
+            create_files: true,
+          )
+          require_relative "#{dir}/address"
+        end
+
+        let(:address) do
+          <<~ADD
+            <Address>
+              Oxford Street
+              <City>London</City>
+              <ZIP>E1 6AN</ZIP>
+            </Address>
+          ADD
+        end
+
+        it "matches parsed xml with input" do
+          expect(defined?(Address)).to eq("constant")
+          expect(Address.from_xml(address).to_xml).to be_equivalent_to(address)
+        end
+      end
+    end
+
+    context "when classes are generated but files are not created" do
+      let(:schema_classes_hash) do
+        described_class.to_models(
+          File.read("spec/fixtures/xml/user.xsd"),
+        )
+      end
+
+      let(:expected_classes) do
+        [
+          "NonNegativeInteger",
+          "PositiveInteger",
+          "Base64Binary",
+          "UnsignedLong",
+          "UnsignedInt",
+          "HexBinary",
+          "Token",
+          "Long",
+          "User",
+        ]
+      end
+
+      it "matches the expected class names of the schema" do
+        expect(schema_classes_hash.keys).to eql(expected_classes)
+      end
+    end
+
+    context "when classes are generated and loaded but files are not created" do
+      before do
+        described_class.to_models(
+          File.read("spec/fixtures/xml/user.xsd"),
+          load_classes: true,
+        )
+      end
+
+      let(:expected_classes) do
+        %w[
+          NonNegativeInteger
+          PositiveInteger
+          Base64Binary
+          UnsignedLong
+          UnsignedInt
+          HexBinary
+          Token
+          Long
+          User
+        ]
+      end
+
+      let(:xml) do
+        <<~XML
+          <User>
+            <id>1112</id>
+            <age>29</age>
+            <token>u9dId901dp13f</token>
+          </User>
+        XML
+      end
+
+      it "matches the expected class names of the schema" do
+        expected_classes.each do |klass|
+          expect(be_const_defined(klass)).to be_truthy
+        end
+        expect(User.from_xml(xml).to_xml).to be_equivalent_to(xml)
+      end
+    end
   end
 
   describe "structure setup methods" do
@@ -136,7 +234,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
               <xsd:attribute name="test_attribute" type="xsd:string"/>
               <xsd:group name="test_group"/>
               <xsd:simpleType name="test_simple_type"/>
-              <xsd:complexType name="test_complex_type"/>
+              <xsd:complexType name="test_complex_type" mixed="true"/>
               <xsd:attributeGroup name="test_attribute_group"/>
             </xsd:schema>
           XSD
@@ -148,7 +246,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
             attributes: { "test_attribute" => { name: "test_attribute", base_class: "xsd:string" } },
             group_types: { "test_group" => {} },
             simple_types: { "test_simple_type" => {} },
-            complex_types: { "test_complex_type" => {} },
+            complex_types: { "test_complex_type" => { mixed: true } },
             attribute_groups: { "test_attribute_group" => {} },
           }
         end
@@ -260,7 +358,15 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
             ct.attribute_group = [Lutaml::Xsd::AttributeGroup.new(name: "test_attribute_group")]
             ct.group = [Lutaml::Xsd::Group.new(name: "test_group")]
             ct.simple_content = [Lutaml::Xsd::SimpleContent.new(name: "test_simple_content")]
-            ct.element_order = ["attribute", "sequence", "choice", "complex_content", "attribute_group", "group", "simple_content"]
+            ct.element_order = create_pattern_mapping([
+                                                        ["Element", "attribute"],
+                                                        ["Element", "sequence"],
+                                                        ["Element", "choice"],
+                                                        ["Element", "complex_content"],
+                                                        ["Element", "attribute_group"],
+                                                        ["Element", "group"],
+                                                        ["Element", "simple_content"],
+                                                      ])
           end
         end
 
@@ -272,6 +378,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
             complex_content: {},
             attribute_groups: [{}],
             group: {},
+            mixed: false,
             simple_content: nil,
           }
         end
@@ -289,7 +396,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
         end
 
         it "initializes the instance variables with empty MappingHash" do
-          expect(described_class.send(:setup_complex_type, complex_type)).to be_empty
+          expect(described_class.send(:setup_complex_type, complex_type)).to eq({ mixed: false })
         end
       end
     end
@@ -299,7 +406,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
         let(:complex_type) do
           Lutaml::Xsd::SimpleContent.new.tap do |ct|
             ct.extension = Lutaml::Xsd::ExtensionSimpleContent.new(base: "test_extension")
-            ct.element_order = ["extension"]
+            ct.element_order = [Lutaml::Model::XmlAdapter::Element.new("Element", "extension")]
           end
         end
 
@@ -314,7 +421,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
         let(:complex_type) do
           Lutaml::Xsd::SimpleContent.new.tap do |ct|
             ct.restriction = Lutaml::Xsd::RestrictionSimpleContent.new(base: "test_restriction")
-            ct.element_order = ["restriction"]
+            ct.element_order = [Lutaml::Model::XmlAdapter::Element.new("Element", "restriction")]
           end
         end
 
@@ -338,7 +445,14 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
               Lutaml::Xsd::Group.new(name: "test_group"),
               Lutaml::Xsd::Group.new(ref: "test_ref"),
             ]
-            ct.element_order = ["sequence", "group", "element", "choice", "element", "group"]
+            ct.element_order = create_pattern_mapping([
+                                                        ["Element", "sequence"],
+                                                        ["Element", "group"],
+                                                        ["Element", "element"],
+                                                        ["Element", "choice"],
+                                                        ["Element", "element"],
+                                                        ["Element", "group"],
+                                                      ])
           end
         end
 
@@ -375,7 +489,10 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
           Lutaml::Xsd::Group.new.tap do |ct|
             ct.sequence = [Lutaml::Xsd::Sequence.new(name: "test_sequence")]
             ct.choice = [Lutaml::Xsd::Choice.new(name: "test_choice")]
-            ct.element_order = ["sequence", "choice"]
+            ct.element_order = create_pattern_mapping([
+                                                        ["Element", "sequence"],
+                                                        ["Element", "choice"],
+                                                      ])
           end
         end
 
@@ -407,7 +524,12 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
             ct.sequence = [Lutaml::Xsd::Sequence.new(name: "test_sequence")]
             ct.choice = [Lutaml::Xsd::Choice.new(name: "test_choice")]
             ct.group = [Lutaml::Xsd::Group.new(name: "test_group")]
-            ct.element_order = ["sequence", "choice", "group", "element"]
+            ct.element_order = create_pattern_mapping([
+                                                        ["Element", "sequence"],
+                                                        ["Element", "choice"],
+                                                        ["Element", "group"],
+                                                        ["Element", "element"],
+                                                      ])
           end
         end
 
@@ -516,7 +638,10 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
           Lutaml::Xsd::AttributeGroup.new.tap do |attr_group|
             attr_group.attribute = [Lutaml::Xsd::Attribute.new(name: "test_name", type: "test_type")]
             attr_group.attribute_group = [Lutaml::Xsd::AttributeGroup.new(name: "test_name", type: "test_type")]
-            attr_group.element_order = ["attribute", "attribute_group"]
+            attr_group.element_order = create_pattern_mapping([
+                                                                ["Element", "attribute"],
+                                                                ["Element", "attribute_group"],
+                                                              ])
           end
         end
 
@@ -622,7 +747,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
             element.min_occurs = 0
             element.max_occurs = 1
             element.complex_type = Lutaml::Xsd::ComplexType.new(name: "test_complex_type")
-            element.element_order = ["complex_type"]
+            element.element_order = [Lutaml::Model::XmlAdapter::Element.new("Element", "complex_type")]
           end
         end
 
@@ -656,11 +781,11 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
             element.type = "test_type"
             element.name = "test_name"
             element.complex_type = Lutaml::Xsd::ComplexType.new(name: "test_complex_type")
-            element.element_order = ["complex_type"]
+            element.element_order = [Lutaml::Model::XmlAdapter::Element.new("Element", "complex_type")]
           end
         end
 
-        let(:expected_hash) { { type_name: "test_type", element_name: "test_name", complex_type: {} } }
+        let(:expected_hash) { { type_name: "test_type", element_name: "test_name", complex_type: { mixed: false } } }
 
         it "returns the expected hash" do
           expect(described_class.send(:setup_element, element)).to eql(expected_hash)
@@ -776,7 +901,12 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
             ]
             extension.sequence = Lutaml::Xsd::Sequence.new
             extension.choice = Lutaml::Xsd::Choice.new
-            extension.element_order = ["attribute", "sequence", "choice", "attribute"]
+            extension.element_order = create_pattern_mapping([
+                                                               ["Element", "attribute"],
+                                                               ["Element", "sequence"],
+                                                               ["Element", "choice"],
+                                                               ["Element", "attribute"],
+                                                             ])
           end
         end
 
@@ -832,12 +962,17 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
       context "when given element contains element_order but no instance relevant elements/instances" do
         let(:element) do
           Lutaml::Xsd::Element.new.tap do |element|
-            element.element_order = ["annotation", "simple_type", "complex_type", "key"]
+            element.element_order = create_pattern_mapping([
+                                                             ["Element", "annotation"],
+                                                             ["Element", "simple_type"],
+                                                             ["Element", "complex_type"],
+                                                             ["Element", "key"],
+                                                           ])
           end
         end
 
         it "raises an error when element_order contains elements that isn't an attribute of the instance" do
-          element.element_order << "test_element"
+          element.element_order << Lutaml::Model::XmlAdapter::Element.new("Element", "test_element")
           expect { described_class.send(:resolved_element_order, element) }.to raise_error(NoMethodError)
         end
 
@@ -854,7 +989,12 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
             element.simple_type = Lutaml::Xsd::SimpleType.new
             element.complex_type = Lutaml::Xsd::ComplexType.new
             element.key = Lutaml::Xsd::Key.new
-            element.element_order = ["annotation", "simple_type", "complex_type", "key"]
+            element.element_order = create_pattern_mapping([
+                                                             ["Element", "annotation"],
+                                                             ["Element", "simple_type"],
+                                                             ["Element", "complex_type"],
+                                                             ["Element", "key"],
+                                                           ])
           end
         end
 
@@ -913,6 +1053,24 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
       end
     end
 
+    describe ".resolve_element_class" do
+      context "when element.type_name is one of the standard classes" do
+        described_class::DEFAULT_CLASSES.each do |standard_class|
+          it "returns the element_class value for #{standard_class.capitalize}" do
+            type_name_hash = to_mapping_hash({ type_name: "xsd:#{standard_class}" })
+            expect(described_class.send(:resolve_element_class, type_name_hash)).to eql(":#{standard_class}")
+          end
+        end
+      end
+
+      context "when element.type_name is not one of the standard classes" do
+        it "returns the element_class value" do
+          type_name_hash = to_mapping_hash({ type_name: "test_st_element1" })
+          expect(described_class.send(:resolve_element_class, type_name_hash)).to eql("TestStElement1")
+        end
+      end
+    end
+
     describe ".resolve_occurs" do
       context "when min_occurs and max_occurs are present" do
         it "returns the collection: true" do
@@ -1392,7 +1550,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
     end
 
     describe ".required_files_elements" do
-      context "when elements are given" do
+      context "when given element's data type is not one of standard class" do
         before do
           described_class.instance_variable_set(:@required_files, [])
           described_class.instance_variable_set(:@elements, elements)
@@ -1421,10 +1579,45 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
           expect(described_class.instance_variable_get(:@required_files)).to eql(["ct_element1", "ct_element2"])
         end
       end
+
+      context "when given element's data type is one of standard class" do
+        before do
+          described_class.instance_variable_set(:@required_files, [])
+          described_class.instance_variable_set(:@elements, elements)
+        end
+
+        after do
+          described_class.instance_variable_set(:@required_files, nil)
+          described_class.instance_variable_set(:@elements, nil)
+        end
+
+        let(:elements) do
+          {
+            "CT_Element1" => to_mapping_hash({ type_name: "w:CT_Element1" }),
+            "CT_Element2" => to_mapping_hash({ type_name: "xsd:string" }),
+          }
+        end
+
+        let(:content) do
+          [
+            to_mapping_hash({ type_name: "CT_Element1" }),
+            to_mapping_hash({ ref_class: "CT_Element2" }),
+          ]
+        end
+
+        it "populates @required_files variable with the names of the required files excluding default classes" do
+          described_class.send(:required_files_elements, content)
+          expect(described_class.instance_variable_get(:@required_files)).to eql(["ct_element1"])
+        end
+      end
     end
   end
 end
 
+def create_pattern_mapping(array)
+  array.map { |type, text| Lutaml::Model::XmlAdapter::Element.new(type, text) }
+end
+
 def to_mapping_hash(content)
   @hash ||= Lutaml::Model::MappingHash.new
   @hash.merge(content)

data/spec/lutaml/model/sequence_spec.rb

@@ -0,0 +1,216 @@
+require "spec_helper"
+require "lutaml/model"
+
+module SequenceSpec
+  class Ceramic < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :name, :string
+    attribute :type, :string
+    attribute :color, :string
+    attribute :bold, :string
+    attribute :text, :string
+    attribute :usage, :string
+    attribute :size, :string
+    attribute :first_name, :string
+    attribute :last_name, :string
+    attribute :tag, :string
+    attribute :temperature, :string
+
+    xml do
+      root "Ceramic"
+      map_element :tag, to: :tag
+
+      sequence do
+        map_element :id, to: :id
+        map_element :name, to: :name
+        map_element :type, to: :type
+        map_element :color, to: :color
+        map_element :bold, to: :bold
+        map_element :text, to: :text
+        sequence do
+          map_element :usage, to: :usage
+          map_element :size, to: :size
+        end
+      end
+
+      sequence do
+        map_element :first_name, to: :first_name
+        map_element :last_name, to: :last_name
+      end
+
+      map_element :temperature, to: :temperature
+    end
+  end
+
+  class CeramicCollection < Lutaml::Model::Serializable
+    attribute :ceramic, Ceramic, collection: 1..2
+
+    xml do
+      root "collection"
+      map_element "ceramic", to: :ceramic
+    end
+  end
+end
+
+RSpec.describe "Sequence" do
+  context "with nesting sequence" do
+    let(:mapper) { SequenceSpec::Ceramic }
+
+    it "don't raise error for a valid instance, if given attribute for sequence has correct order" do
+      xml = <<~XML
+        <Ceramic>
+          <tag>Nik</tag>
+          <id>1</id>
+          <name>Vase</name>
+          <type>Decorative</type>
+          <color>Blue</color>
+          <bold>Heading</bold>
+          <text>Header</text>
+          <usage>Indoor</usage>
+          <size>Medium</size>
+          <first_name>Dale</first_name>
+          <last_name>Steyn</last_name>
+          <temperature>Normal</temperature>
+        </Ceramic>
+      XML
+
+      expect { mapper.from_xml(xml) }.not_to raise_error
+    end
+
+    it "don't raise error for a valid instance with sequence range, if given attribute for sequence has correct order" do
+      xml = <<~XML
+        <collection>
+          <ceramic>
+            <tag>Nik</tag>
+            <id>1</id>
+            <name>Vase</name>
+            <type>Decorative</type>
+            <color>Blue</color>
+            <bold>Heading</bold>
+            <text>Header</text>
+            <usage>Indoor</usage>
+            <size>Medium</size>
+            <first_name>Dale</first_name>
+            <last_name>Steyn</last_name>
+            <temperature>Normal</temperature>
+          </ceramic>
+          <ceramic>
+            <tag>Nik</tag>
+            <id>1</id>
+            <name>Vase</name>
+            <type>Decorative</type>
+            <color>Blue</color>
+            <bold>Heading</bold>
+            <text>Header</text>
+            <usage>Indoor</usage>
+            <size>Medium</size>
+            <first_name>Dale</first_name>
+            <last_name>Steyn</last_name>
+            <temperature>Normal</temperature>
+          </ceramic>
+        </collection>
+      XML
+
+      expect do
+        SequenceSpec::CeramicCollection.from_xml(xml)
+      end.not_to raise_error
+    end
+
+    it "raises error, if given attributes order is incorrect in sequence" do
+      xml = <<~XML
+        <Ceramic>
+          <tag>Nik</tag>
+          <temperature>High</temperature>
+          <first_name>Micheal</first_name>
+          <id>1</id>
+          <name>Vase</name>
+          <type>Decorative</type>
+          <color>Blue</color>
+          <bold>Heading</bold>
+          <usage>Indoor</usage>
+          <size>Medium</size>
+          <last_name>Johnson</last_name>
+          <text>Header</text>
+        </Ceramic>
+      XML
+
+      expect do
+        mapper.from_xml(xml)
+      end.to raise_error(Lutaml::Model::IncorrectSequenceError) do |error|
+        expect(error.message).to eq("Element `usage` does not match the expected sequence order element `text`")
+      end
+    end
+
+    it "raises error with sequence range, if given attributes order is incorrect in sequence" do
+      invalid_xml = <<~XML
+        <collection>
+          <ceramic>
+            <id>1</id>
+            <name>Vase</name>
+            <type>Decorative</type>
+            <color>Blue</color>
+            <bold>Heading</bold>
+            <text>Header</text>
+            <usage>Indoor</usage>
+            <size>Medium</size>
+            <first_name>Dale</first_name>
+            <last_name>Steyn</last_name>
+            <temperature>Normal</temperature>
+            <tag>Nik</tag>
+          </ceramic>
+
+          <ceramic>
+            <id>2</id>
+            <name>Nick</name>
+            <type>Unique</type>
+            <color>Red</color>
+            <bold>Name</bold>
+            <text>Body</text>
+            <usage>Outdoor</usage>
+            <size>Small</size>
+            <first_name>Smith</first_name>
+            <last_name>Ash</last_name>
+            <temperature>High</temperature>
+            <tag>Adid</tag>
+          </ceramic>
+
+          <ceramic>
+            <id>3</id>
+            <name>Starc</name>
+            <type>Int</type>
+            <color>White</color>
+            <bold>Act</bold>
+            <text>Footer</text>
+            <usage>Nothing</usage>
+            <size>Large</size>
+            <first_name>Dale</first_name>
+            <last_name>Steyn</last_name>
+            <temperature>Normal</temperature>
+            <tag>Bet</tag>
+          </ceramic>
+        </collection>
+      XML
+
+      expect do
+        SequenceSpec::CeramicCollection.from_xml(invalid_xml).validate!
+      end.to raise_error(Lutaml::Model::ValidationError) do |error|
+        expect(error).to include(Lutaml::Model::CollectionCountOutOfRangeError)
+        expect(error.error_messages).to eq(["ceramic count is 3, must be between 1 and 2"])
+      end
+    end
+
+    it "raises error, if mapping other map_element are defined in sequence" do
+      expect do
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :type, :string
+
+          xml do
+            sequence do
+              map_attribute :type, to: :type
+            end
+          end
+        end
+      end.to raise_error(Lutaml::Model::UnknownSequenceMappingError, "map_attribute is not allowed in sequence")
+    end
+  end
+end