schematic 0.0.8 → 0.1.2

data/lib/schematic/version.rb

@@ -1,3 +1,3 @@
 module Schematic
-  VERSION = "0.0.8"
+  VERSION = "0.1.2"
 end

data/schematic.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency('with_model')
   s.add_development_dependency('nokogiri')
   s.add_development_dependency('sqlite3')
+  s.add_development_dependency('autotest')
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/spec/schematic/generator/restrictions/enumeration_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe Schematic::Generator::Restrictions::Enumeration do
+  describe ".to_xsd" do
+    context "with a model with inclusion validations" do
+      subject { sanitize_xml(EnumerationModel.to_xsd) }
+      with_model :enumeration_model do
+        table :id => false do |t|
+          t.string "title"
+        end
+
+        model do
+          validates :title, :inclusion => { :in => ["a", "b", "c"] }
+        end
+      end
+
+      it "should validate against it's own XSD" do
+        invalid_instance = EnumerationModel.new(:title => "d")
+        xml = [invalid_instance].to_xml
+        lambda {
+          validate_xml_against_xsd(xml, subject)
+        }.should raise_error
+        valid_instance = EnumerationModel.new(:title => "a")
+        xml = [valid_instance].to_xml
+        lambda {
+          validate_xml_against_xsd(xml, subject)
+        }.should_not raise_error
+      end
+
+      it "should mark that the field with the allowed values" do
+        xsd = generate_xsd_for_model(EnumerationModel) do
+          <<-XML
+              <xs:element name="title" minOccurs="0" maxOccurs="1">
+                <xs:complexType>
+                  <xs:simpleContent>
+                    <xs:restriction base="String">
+                      <xs:enumeration value="a"/>
+                      <xs:enumeration value="b"/>
+                      <xs:enumeration value="c"/>
+                    </xs:restriction>
+                  </xs:simpleContent>
+                </xs:complexType>
+              </xs:element>
+          XML
+        end
+
+        subject.should == xsd
+      end
+    end
+  end
+end
+
+

data/spec/schematic/generator/restrictions/length_spec.rb

@@ -0,0 +1,181 @@
+require "spec_helper"
+
+describe Schematic::Generator::Restrictions::Length do
+  describe ".to_xsd" do
+    context "with a model with range length validations" do
+      subject { sanitize_xml(LengthModelRange.to_xsd) }
+      with_model :length_model_range do
+        table :id => false do |t|
+          t.string "title"
+        end
+
+        model do
+          validates :title, :length => { :within => 10..20 }
+        end
+      end
+
+      it "should validate against it's own XSD" do
+        invalid_instance = LengthModelRange.new(:title => "A" * 9)
+        xml = [invalid_instance].to_xml
+        lambda {
+          validate_xml_against_xsd(xml, subject)
+        }.should raise_error
+        invalid_instance = LengthModelRange.new(:title => "A" * 21)
+        xml = [invalid_instance].to_xml
+        lambda {
+          validate_xml_against_xsd(xml, subject)
+        }.should raise_error
+      end
+    end
+
+    context "with a model with using the range alias length validations" do
+      subject { sanitize_xml(LengthModelRange.to_xsd) }
+      with_model :length_model_range do
+        table :id => false do |t|
+          t.string "title"
+        end
+
+        model do
+          validates :title, :length => { :in => 10..20 }
+        end
+      end
+
+      it "should validate against it's own XSD" do
+        invalid_instance = LengthModelRange.new(:title => "A" * 9)
+        xml = [invalid_instance].to_xml
+        lambda {
+          validate_xml_against_xsd(xml, subject)
+        }.should raise_error
+        invalid_instance = LengthModelRange.new(:title => "A" * 21)
+        xml = [invalid_instance].to_xml
+        lambda {
+          validate_xml_against_xsd(xml, subject)
+        }.should raise_error
+      end
+    end
+
+    context "with a model with minimum length validations" do
+      subject { sanitize_xml(LengthModelMinimum.to_xsd) }
+      with_model :length_model_minimum do
+        table :id => false do |t|
+          t.string "title"
+        end
+
+        model do
+          validates :title, :length => { :minimum => 10 }
+        end
+      end
+
+      it "should validate against it's own XSD" do
+        invalid_instance = LengthModelMinimum.new(:title => "A" * 9)
+        xml = [invalid_instance].to_xml
+        lambda {
+          validate_xml_against_xsd(xml, subject)
+        }.should raise_error
+      end
+    end
+
+    context "with a model with maximum length validations" do
+      subject { sanitize_xml(LengthModelOne.to_xsd) }
+      context "when allow blank is true" do
+        with_model :length_model_one do
+          table :id => false do |t|
+            t.string "title"
+          end
+
+          model do
+            validates :title, :length => { :maximum => 100 }, :allow_blank => true
+          end
+        end
+
+        it "should validate against it's own XSD" do
+          invalid_instance = LengthModelOne.new(:title => "A" * 201)
+          xml = [invalid_instance].to_xml
+          lambda {
+            validate_xml_against_xsd(xml, subject)
+          }.should raise_error
+        end
+
+        it "should mark that the field minimum occurrences is 0 but still list the length" do
+          xsd = generate_xsd_for_model(LengthModelOne) do
+            <<-XML
+              <xs:element name="title" minOccurs="0" maxOccurs="1">
+                <xs:complexType>
+                  <xs:simpleContent>
+                    <xs:restriction base="String">
+                      <xs:maxLength value="100"/>
+                    </xs:restriction>
+                  </xs:simpleContent>
+                </xs:complexType>
+              </xs:element>
+            XML
+          end
+
+          subject.should == xsd
+        end
+      end
+
+      context "when allow blank is false" do
+        subject { sanitize_xml(LengthModelTwo.to_xsd) }
+        with_model :length_model_two do
+          table :id => false do |t|
+            t.string "title"
+          end
+
+          model do
+            validates :title, :length => { :maximum => 100 }, :allow_blank => false
+          end
+        end
+
+        it "should mark that the field maximum length to 100" do
+          xsd = generate_xsd_for_model(LengthModelTwo) do
+            <<-XML
+              <xs:element name="title" minOccurs="0" maxOccurs="1">
+                <xs:complexType>
+                  <xs:simpleContent>
+                    <xs:restriction base="String">
+                      <xs:maxLength value="100"/>
+                    </xs:restriction>
+                  </xs:simpleContent>
+                </xs:complexType>
+              </xs:element>
+            XML
+          end
+
+          subject.should == xsd
+        end
+      end
+
+      context "when there is a condition" do
+        subject { sanitize_xml(LengthModelThree.to_xsd) }
+        with_model :length_model_three do
+          table :id => false do |t|
+            t.string "title"
+          end
+
+          model do
+            validates :title, :length => { :maximum => 100 }, :if => lambda { |model| false }
+          end
+        end
+
+        it "should not record the max length" do
+          xsd = generate_xsd_for_model(LengthModelThree) do
+            <<-XML
+              <xs:element name="title" minOccurs="0" maxOccurs="1">
+                <xs:complexType>
+                  <xs:simpleContent>
+                    <xs:restriction base="String">
+                    </xs:restriction>
+                  </xs:simpleContent>
+                </xs:complexType>
+              </xs:element>
+            XML
+          end
+
+          subject.should == xsd
+        end
+      end
+    end
+  end
+end
+

data/spec/schematic/generator/restrictions/pattern_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+describe Schematic::Generator::Restrictions::Enumeration do
+  describe ".to_xsd" do
+    context "with a model with format validations" do
+      subject { sanitize_xml(PatternModel.to_xsd) }
+      with_model :pattern_model do
+        table :id => false do |t|
+          t.string "title"
+        end
+
+        model do
+          validates :title, :format => { :with => /[a-z]#[0-9]/ }
+        end
+      end
+
+      it "should validate against it's own XSD" do
+        invalid_instance = PatternModel.new(:title => "1-2")
+        xml = [invalid_instance].to_xml
+        lambda {
+          validate_xml_against_xsd(xml, subject)
+        }.should raise_error
+        valid_instance = PatternModel.new(:title => "a#5")
+        xml = [valid_instance].to_xml
+        lambda {
+          validate_xml_against_xsd(xml, subject)
+        }.should_not raise_error
+      end
+
+      it "should mark that the field with the allowed values" do
+        xsd = generate_xsd_for_model(PatternModel) do
+          <<-XML
+              <xs:element name="title" minOccurs="0" maxOccurs="1">
+                <xs:complexType>
+                  <xs:simpleContent>
+                    <xs:restriction base="String">
+                      <xs:pattern value="[a-z]#[0-9]"/>
+                    </xs:restriction>
+                  </xs:simpleContent>
+                </xs:complexType>
+              </xs:element>
+          XML
+        end
+
+        subject.should == xsd
+      end
+    end
+  end
+end
+
+
+

data/spec/schematic/serializers/xsd_extend_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+describe Schematic::Serializers::Xsd do
+  before do
+    class EmptyModel < ActiveRecord::Base
+      def self.columns
+        []
+      end
+    end
+  end
+
+  describe ".extend" do
+    context "when the model inherits ActiveRecord::Base" do
+      subject { EmptyModel }
+
+      it "should allow the model to be extended" do
+        lambda {
+          subject.class_eval do
+          extend Schematic::Serializers::Xsd
+          end
+        }.should_not raise_error
+      end
+    end
+
+    context "when the model does not inherit ActiveRecord::Base" do
+      subject { Object }
+
+      it "should raise an exception" do
+        lambda {
+          subject.class_eval do
+          extend Schematic::Serializers::Xsd
+          end
+        }.should raise_error(Schematic::InvalidClass)
+      end
+    end
+  end
+end

data/spec/schematic/serializers/xsd_validation_presence_spec.rb

@@ -0,0 +1,95 @@
+require "spec_helper"
+
+describe Schematic::Serializers::Xsd do
+  describe ".to_xsd" do
+    context "with a model with presence of validations" do
+      subject { sanitize_xml(SomeModel.to_xsd) }
+      context "when allow blank is true" do
+        with_model :some_model do
+          table :id => false do |t|
+            t.string "title"
+          end
+
+          model do
+            validate :title, :presence => true, :allow_blank => true
+          end
+        end
+
+        it "should mark that the field minimum occurrences is 0" do
+          xsd = generate_xsd_for_model(SomeModel) do
+            <<-XML
+              <xs:element name="title" minOccurs="0" maxOccurs="1">
+                <xs:complexType>
+                  <xs:simpleContent>
+                    <xs:restriction base="String">
+                    </xs:restriction>
+                  </xs:simpleContent>
+                </xs:complexType>
+              </xs:element>
+            XML
+          end
+
+          subject.should == xsd
+        end
+      end
+
+      context "when allow blank is false" do
+        with_model :some_model do
+          table :id => false do |t|
+            t.string "title"
+          end
+
+          model do
+            validates :title, :presence => true
+          end
+        end
+
+        it "should mark that the field minimum occurrences is 1" do
+          xsd = generate_xsd_for_model(SomeModel) do
+            <<-XML
+              <xs:element name="title" minOccurs="1" maxOccurs="1">
+                <xs:complexType>
+                  <xs:simpleContent>
+                    <xs:restriction base="String">
+                    </xs:restriction>
+                  </xs:simpleContent>
+                </xs:complexType>
+              </xs:element>
+            XML
+          end
+
+          subject.should == xsd
+        end
+      end
+
+      context "when there is a condition" do
+        with_model :some_model do
+          table :id => false do |t|
+            t.string "title"
+          end
+
+          model do
+            validates :title, :presence => true, :if => lambda { |model| false }
+          end
+        end
+
+        it "should mark that the field minimum occurrences is 0" do
+          xsd = generate_xsd_for_model(SomeModel) do
+            <<-XML
+              <xs:element name="title" minOccurs="0" maxOccurs="1">
+                <xs:complexType>
+                  <xs:simpleContent>
+                    <xs:restriction base="String">
+                    </xs:restriction>
+                  </xs:simpleContent>
+                </xs:complexType>
+              </xs:element>
+            XML
+          end
+
+          subject.should == xsd
+        end
+      end
+    end
+  end
+end

data/spec/schematic/serializers/xsd_xsd_ignore_methods_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe Schematic::Serializers::Xsd do
+  describe ".xsd_ignore_methods" do
+    with_model :some_model do
+      table :id => false do |t|
+        t.string :title
+      end
+
+      model do
+        def self.xsd_ignore_methods
+          [:title]
+        end
+      end
+    end
+
+    it "should exclude the methods" do
+      xsd = generate_xsd_for_model(SomeModel) do
+      end
+
+      sanitize_xml(SomeModel.to_xsd).should eq(xsd)
+    end
+  end
+
+end