praxis 2.0.pre.4 → 2.0.pre.9

data/spec/praxis/handlers/xml_spec.rb

@@ -1,177 +0,0 @@
-require 'spec_helper'
-
-describe Praxis::Handlers::XML do
-
-  describe '#parse' do
-    shared_examples 'xml something' do
-      it 'works' do
-        expect(subject.parse(parsed.to_xml)).to eq(parsed)
-      end
-    end
-
-    #  XML_TYPE_NAMES = {
-    #    "Symbol"     => "symbol",
-    #    "Fixnum"     => "integer",
-    #    "Bignum"     => "integer",
-    #    "BigDecimal" => "decimal",
-    #    "Float"      => "float",
-    #    "TrueClass"  => "boolean",
-    #    "FalseClass" => "boolean",
-    #    "Date"       => "date",
-    #    "DateTime"   => "dateTime",
-    #    "Time"       => "dateTime"
-    #  }
-
-    context "Parsing symbols" do
-      let(:xml){ '<objects type="array"><object type="symbol">a_symbol</object></objects>' }
-      let(:parsed){ [:a_symbol] }
-      it_behaves_like 'xml something'
-    end
-
-    context "Parsing integers" do
-      let(:xml){ '<objects type="array"><object type="integer">1234</object></objects>' }
-      let(:parsed){ [1234] }
-      it_behaves_like 'xml something'
-    end
-
-    context "Parsing decimals" do
-      let(:xml){ '<objects type="array"><object type="decimal">0.1</object></objects>' }
-      let(:parsed){ [0.1] }
-      it_behaves_like 'xml something'
-    end
-
-    context "Parsing floats" do
-      let(:xml){ '<objects type="array"><object type="float">0.1</object></objects>' }
-      let(:parsed){ [0.1] }
-      it_behaves_like 'xml something'
-    end
-
-    context "Parsing booleans" do
-      context "that are true" do
-        let(:xml){ '<objects type="array"><object type="boolean">true</object></objects>' }
-        let(:parsed){ [true] }
-        it_behaves_like 'xml something'
-      end
-      context "that are false" do
-        let(:xml){ '<objects type="array"><object type="boolean">false</object></objects>' }
-        let(:parsed){ [false] }
-        it_behaves_like 'xml something'
-
-      end
-    end
-
-    context "Parsing dates" do
-      let(:xml){ '<objects type="array"><object type="date">2001-01-01</object></objects>' }
-      let(:parsed){ [Date.parse("2001-01-01")] }
-      it_behaves_like 'xml something'
-    end
-
-    context "Parsing dateTimes" do
-      let(:xml){ '<objects type="array"><object type="dateTime">2015-03-13T19:34:40-07:00</object></objects>' }
-      let(:parsed){ [DateTime.parse("2015-03-13T19:34:40-07:00")] }
-      it_behaves_like 'xml something'
-    end
-
-    context "Parsing hashes" do
-      context "that are empty" do
-        let(:xml){ "<hash></hash>" }
-
-        it 'get converted to empty strings' do
-          expect(subject.parse(xml)).to eq('')
-        end
-      end
-
-      context "with a couple of elements" do
-        let(:xml){ '<hash><one type="integer">1</one><two type="integer">2</two></hash>' }
-        let(:parsed){ {"one"=>1, "two"=>2} }
-        it_behaves_like 'xml something'
-      end
-      context "with hyphenated elements" do
-        let(:xml){ '<hash><part-one type="integer">1</part-one><part-two type="integer">2</part-two></hash>' }
-        let(:parsed){ {"part_one"=>1, "part_two"=>2} }
-        it_behaves_like 'xml something'
-      end
-      context "with a nested hash" do
-        let(:xml){ '<hash><one type="integer">1</one><sub_hash><first>hello</first></sub_hash></hash>' }
-        let(:parsed){ {"one"=>1, "sub_hash"=>{"first"=>"hello"} } }
-        it_behaves_like 'xml something'
-      end
-      context "with a nested array" do
-        let(:xml){ '<hash><one type="integer">1</one><two type="array"><object>just text</object></two></hash>' }
-        let(:parsed){ {"one"=>1, "two" => ["just text"] } }
-        it_behaves_like 'xml something'
-      end
-
-    end
-
-    context "Parsing an Array" do
-      context 'with a couple of simple elements in it' do
-        let(:xml){ '<objects type="array"><object>just text</object><object type="integer">1</object></objects>' }
-        let(:parsed){ ["just text", 1] }
-        it_behaves_like 'xml something'
-      end
-      context "with a nested hash" do
-        let(:xml){ '<objects type="array"><object>just text</object><object><one type="integer">1</one></object></objects>' }
-        let(:parsed){ ["just text", { "one" => 1}] }
-        it_behaves_like 'xml something'
-      end
-    end
-
-    context "Parsing XML strings created with .to_xml" do
-      let(:xml){ parsed.to_xml }
-      context 'array with a couple of simple elements in it' do
-        let(:parsed){ ["just text", 1] }
-        it_behaves_like 'xml something'
-      end
-      context 'a hash with a couple of simple elements in it' do
-        let(:parsed){ { "one"=>"just text", "two"=> 1 } }
-        it_behaves_like 'xml something'
-      end
-      context 'a array with elements of all types' do
-        let(:parsed){ ["just text",:a,1,BigDecimal(100),0.1,true,Date.new] }
-        it_behaves_like 'xml something'
-      end
-      context 'a hash with a complex substructure' do
-        let(:parsed) do
-          Hash(
-            "text" => "just text",
-            "symbol" => :a,
-            "num" => 1,
-            "bd" => BigDecimal(100),
-            "float" => 0.1,
-            "truthyness" => true,
-            "day" => Date.new,
-            "empty_string" => ""
-          )
-        end
-        it_behaves_like 'xml something'
-      end
-
-      context "transformed characters when using .to_xml" do
-        context 'underscores become dashes' do
-          let(:xml){ {"one_thing"=>1, "two_things"=>2}.to_xml  }
-          it do
-            doc = Nokogiri::XML(xml)
-
-            expect(doc.search('one-thing')).to_not be_empty
-            expect(doc.search('two-things')).to_not be_empty
-          end
-        end
-        context 'spaces become dashes' do
-          let(:xml){ {"one thing"=>1, "two things"=>2}.to_xml  }
-          let(:parsed){ {"one-thing"=>1, "two-things"=>2} }
-          it do
-            doc = Nokogiri::XML(xml)
-
-            expect(doc.search('one-thing')).to_not be_empty
-            expect(doc.search('two-things')).to_not be_empty
-          end
-        end
-      end
-    end
-
-    describe '#generate' do
-      it 'has tests'
-    end
-  end
-end

data/spec/praxis/links_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-
-describe Praxis::Links do
-  let(:owner_resource) do
-    double('owner', id: 100, name: /[:name:]/.gen, href: '/')
-  end
-
-  let(:manager_resource) do
-    double('manager', id: 101, name: /[:name:]/.gen, href: '/')
-  end
-
-  let(:resource) do
-    double('address', id: 1, name: 'Home', owner: owner_resource, manager: manager_resource)
-  end
-
-  subject(:link) { described_class.for(Address) }
-
-  it 'returns the link class for the media type if defined' do
-    expect(link.for(Address)).to eq(link)
-  end
-
-  it 'are marked as anonymous' do
-    described = link.for(Address).describe
-    expect(described[:anonymous]).to be(true)
-  end
-
-  context 'contents' do
-    subject(:view) { link.view(:default) }
-
-    its(:name)      { should eq(:default) }
-    its(:schema)    { should eq(Address::Links) }
-    its(:contents)  { should have_key(:owner) }
-    its(:contents)  { should have_key(:super) }
-  end
-
-  context 'rendering' do
-    let(:example){ Address.example }
-    context 'for :default' do
-      subject(:rendered_links){ example.render(view: :default)[:links] }
-
-      it 'should use the :link for rendering its attributes' do
-        example.render(view: :default)[:links]
-        expect(rendered_links[:owner]).to eq( example.owner.render(view: :link))
-      end
-    end
-    context 'for :master' do
-      subject(:rendered_links){ example.render(view: :master)[:links] }
-      it 'should use the :link for rendering its attributes' do
-        expect(rendered_links[:owner]).to eq( example.owner.render(view: :link))
-      end
-    end
-  end
-
-  context '.example' do
-    subject(:example) { Address.example }
-
-    its('links.owner') { should be(example.owner) }
-    its('links.super') { should be(example.object.manager) }
-
-    it 'does not respond to non-top-level attributes from links' do
-      expect { example.super }.to raise_error(NoMethodError)
-    end
-
-    it 'responds to non-top-level attributes from links on its inner Struct' do
-      expect(example.links.super).to be(example.object.manager)
-    end
-  end
-end