restfulness 0.3.2 → 0.3.3

data/spec/unit/headers/accept_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Restfulness::Headers::Accept do
+
+  let :klass do
+    Restfulness::Headers::Accept
+  end
+
+  describe "initialization" do
+
+    it "should work without string" do
+      obj = klass.new
+      expect(obj.media_types).to be_empty
+    end
+
+    it "should parse a basic string" do
+      obj = klass.new("application/json")
+      expect(obj.media_types.first.to_s).to eql("application/json")
+    end
+
+  end
+
+  describe "parsing" do
+
+    it "should parse array of media types" do
+      obj = klass.new("application/json, text/*")
+      expect(obj.media_types.length).to eql(2)
+      expect(obj.media_types.first.to_s).to eql("application/json")
+    end
+
+    it "should parse and re-order media types" do
+      obj = klass.new("text/plain, application/json; version=1, text/*")
+      expect(obj.media_types.length).to eql(3)
+      expect(obj.media_types.first.to_s).to eql("application/json;version=1")
+      expect(obj.media_types.last.to_s).to eql("text/*")
+    end
+
+  end
+
+  describe "#version" do
+    it "should attempt to provide version" do
+      obj = klass.new("text/plain, application/json; version=1, text/*")
+      expect(obj.version).to eql("1")
+    end
+  end
+
+  describe "#json?" do
+    it "should confirm if content includes json" do
+      obj = klass.new("text/plain, application/json; version=1, text/*")
+      expect(obj.json?).to be true
+    end
+    it "should confirm if json not accepted" do
+      obj = klass.new("text/plain, text/*")
+      expect(obj.json?).to be false
+    end
+  end
+
+
+  describe "#xml?" do
+    it "should confirm if content includes xml" do
+      obj = klass.new("text/plain, application/xml; version=1, text/*")
+      expect(obj.xml?).to be true
+    end
+    it "should confirm if json not accepted" do
+      obj = klass.new("text/plain, application/json, text/*")
+      expect(obj.xml?).to be false
+    end
+  end
+
+end

data/spec/unit/headers/media_type_spec.rb

@@ -0,0 +1,262 @@
+require 'spec_helper'
+
+describe Restfulness::Headers::MediaType do
+
+  let :klass do
+    Restfulness::Headers::MediaType
+  end
+
+  describe "initialization" do
+
+    it "should be able to except no parameter and set defaults" do
+      obj = klass.new
+      expect(obj.type).to eql("*")
+      expect(obj.subtype).to eql("*")
+      expect(obj.parameters).to eql({})
+      expect(obj.vendor).to eql("")
+      expect(obj.suffix).to eql("")
+    end
+
+    it "should handle string and parse" do
+      obj = klass.new("application/json")
+      expect(obj.type).to eql("application")
+      expect(obj.subtype).to eql("json")
+    end
+
+  end
+
+  describe "parsing" do
+
+    it "should handle params" do
+      obj = klass.new("applcation/json;version=2")
+      expect(obj.subtype).to eql('json')
+      expect(obj.parameters[:version]).to eql("2")
+    end
+
+    it "should handle params with white space" do
+      obj = klass.new("applcation/json; version=3")
+      expect(obj.subtype).to eql('json')
+      expect(obj.parameters[:version]).to eql("3")
+    end
+
+    it "should handle multiple params" do
+      obj = klass.new("applcation/json;version=2;test=yes")
+      expect(obj.subtype).to eql('json')
+      expect(obj.parameters[:version]).to eql("2")
+      expect(obj.parameters[:test]).to eql("yes")
+    end
+
+    it "should handle suffix" do
+      obj = klass.new("applcation/xhtml+xml")
+      expect(obj.subtype).to eql('xhtml')
+      expect(obj.suffix).to eql('xml')
+    end
+
+    it "should handle vendor" do
+      obj = klass.new("applcation/vnd.example.user; version=3")
+      expect(obj.subtype).to eql('user')
+      expect(obj.vendor).to eql('example')
+      expect(obj.suffix).to eql('')
+      expect(obj.parameters[:version]).to eql("3")
+    end
+
+    it "should handle vendor with suffix" do
+      obj = klass.new("applcation/vnd.example.user+json; version=3")
+      expect(obj.subtype).to eql('user')
+      expect(obj.vendor).to eql('example')
+      expect(obj.suffix).to eql('json')
+      expect(obj.parameters[:version]).to eql("3")
+    end
+
+    it "should handle vendor with domain" do
+      obj = klass.new("applcation/vnd.example.com.user; version=3")
+      expect(obj.subtype).to eql('user')
+      expect(obj.vendor).to eql('example.com')
+      expect(obj.suffix).to eql('')
+      expect(obj.parameters[:version]).to eql("3")
+    end
+
+  end
+
+  describe "conversion to string" do
+    
+    it "should handle empty type" do
+      obj = klass.new
+      expect(obj.to_s).to eql("*/*")
+    end
+
+    it "should handle basic type" do
+      obj = klass.new
+      obj.type = "application"
+      obj.subtype = "json"
+      expect(obj.to_s).to eql('application/json')
+    end
+
+    it "should handle parameter" do
+      obj = klass.new
+      obj.type = "application"
+      obj.subtype = "json"
+      obj.parameters[:version] = 1
+      expect(obj.to_s).to eql('application/json;version=1')
+    end
+
+    it "should handle multiple parameters" do
+      obj = klass.new
+      obj.type = "application"
+      obj.subtype = "json"
+      obj.parameters[:version] = 1
+      obj.parameters[:charset] = "UTF-8"
+      expect(obj.to_s).to eql('application/json;version=1;charset=UTF-8')
+    end
+
+    it "should handle suffix" do
+      obj = klass.new
+      obj.type = "application"
+      obj.subtype = "xhtml"
+      obj.suffix = "xml"
+      expect(obj.to_s).to eql('application/xhtml+xml')
+    end
+
+    it "should handle vendor" do
+      obj = klass.new
+      obj.type = "application"
+      obj.vendor = "example.com"
+      obj.subtype = "user"
+      expect(obj.to_s).to eql('application/vnd.example.com.user')
+    end
+
+    it "should handle vendor with suffix" do
+      obj = klass.new
+      obj.type = "application"
+      obj.vendor = "example.com"
+      obj.subtype = "user"
+      obj.suffix = "json"
+      expect(obj.to_s).to eql('application/vnd.example.com.user+json')
+    end
+
+    it "should handle vendor with suffix and params" do
+      obj = klass.new
+      obj.type = "application"
+      obj.vendor = "example.com"
+      obj.subtype = "user"
+      obj.suffix = "json"
+      obj.parameters[:version] = "1"
+      expect(obj.to_s).to eql('application/vnd.example.com.user+json;version=1')
+    end
+
+  end
+
+  describe "comparisons" do
+    
+    describe "with a string" do
+      
+      it "should compare matching strings" do
+        obj = klass.new("application/json")
+        expect(obj == "application/json").to be true
+      end
+
+      it "should fail on non-matching strings" do
+        obj = klass.new("application/xhtml+xml")
+        expect(obj == "application/xml").to be false
+      end
+
+      it "should ignore whitespace" do
+        obj = klass.new("application/json;version=1")
+        expect(obj == "application/json; version=1").to be true
+      end
+
+    end
+
+    describe "with an object" do
+
+      it "should compare matching objs" do
+        obj = klass.new("application/json")
+        obj2 = klass.new("application/json")
+        expect(obj == obj2).to be true
+      end
+
+      it "should compare non-matching objs" do
+        obj = klass.new("application/json")
+        obj2 = klass.new("application/xml")
+        expect(obj == obj2).to be false
+      end
+
+      it "should compare complex objects" do
+        obj = klass.new("application/vnd.example.com.user+json;version=1")
+        obj2 = klass.new("application/vnd.example.com.user+json;version=1")
+        expect(obj == obj2).to be true
+      end
+     
+    end
+
+    describe "with rubbish" do
+      it "should raise an exception" do
+        obj = klass.new("application/json")
+        expect {
+          obj == 1
+        }.to raise_error(/Invalid type comparison/)
+      end
+    end
+  end
+
+  describe "parameter wrappers" do
+
+    it "should provide charset" do
+      obj = klass.new("application/json; charset=UTF-8")
+      expect(obj.charset).to eql("UTF-8")
+    end
+
+    it "should provide version" do
+      obj = klass.new("application/json; version=2")
+      expect(obj.version).to eql("2")
+    end
+
+  end
+
+  describe "type tests" do
+
+    it "should should match basic json type" do
+      obj = klass.new("application/json; version=2")
+      expect(obj.json?).to be true
+    end
+
+    it "should should match vendored json type" do
+      obj = klass.new("application/vnd.example.com.user+json; version=2")
+      expect(obj.json?).to be true
+    end
+
+    it "should should match basic xml type" do
+      obj = klass.new("application/xml")
+      expect(obj.json?).to be false
+      expect(obj.xml?).to be true
+    end
+
+    it "should should match vendored json type" do
+      obj = klass.new("application/vnd.example.com.user+xml; version=2")
+      expect(obj.json?).to be false
+      expect(obj.xml?).to be true
+    end
+
+    it "should match text type" do
+      obj = klass.new("text/plain")
+      expect(obj.text?).to be true
+    end
+
+    it "should not match non-text type" do
+      obj = klass.new("application/json")
+      expect(obj.text?).to be false
+    end
+
+    it "should match form type" do
+      obj = klass.new("application/x-www-form-urlencoded")
+      expect(obj.form?).to be true
+    end
+
+    it "should not match non-text type" do
+      obj = klass.new("application/json")
+      expect(obj.form?).to be false
+    end
+
+  end
+
+end

data/spec/unit/http_authentication/basic_spec.rb

@@ -15,25 +15,25 @@ describe Restfulness::HttpAuthentication::Basic do
   describe "#initialize" do
     it "should set the header" do
       obj = klass.new(header)
-      obj.header.should eql(header)
+      expect(obj.header).to eql(header)
     end
   end
 
   describe "#valid?" do
     it "should detect valid schema and credentials" do
       obj = klass.new(header)
-      obj.valid?.should be_true
+      expect(obj.valid?).to be true
     end
 
     it "should reject different schema" do
       obj = klass.new(header_klass.new("Fooo Bar"))
-      obj.valid?.should be_false
+      expect(obj.valid?).to be false
     end
 
     it "should reject if the basic request credentials are of invalid length" do
       creds = ::Base64.strict_encode64("username")
       obj = klass.new(header_klass.new("Fooo #{creds}"))
-      obj.valid?.should be_false
+      expect(obj.valid?).to be false
     end
   end
 
@@ -41,9 +41,9 @@ describe Restfulness::HttpAuthentication::Basic do
 
     it "should decode and prepare the params" do
       obj = klass.new(header)
-      obj.credentials.length.should eql(2)
-      obj.username.should eql('Aladdin')
-      obj.password.should eql('open sesame')
+      expect(obj.credentials.length).to eql(2)
+      expect(obj.username).to eql('Aladdin')
+      expect(obj.password).to eql('open sesame')
     end
 
   end

data/spec/unit/path_spec.rb

@@ -25,25 +25,25 @@ describe Restfulness::Path do
     
     it "should assign route" do
       obj = klass.new(simple_route, '/project')
-      obj.route.should eql(simple_route)
+      expect(obj.route).to eql(simple_route)
     end
 
     context "simple paths" do
       it "should prepare basic path" do
         obj = klass.new(simple_route, '/project')
-        obj.components.should eql(['project'])
-        obj.params[:id].should be_nil
+        expect(obj.components).to eql(['project'])
+        expect(obj.params[:id]).to be_nil
       end
 
       it "should prepare irregular path components" do
         obj = klass.new(simple_route, '/project/')
-        obj.components.should eql(['project'])
+        expect(obj.components).to eql(['project'])
       end
 
       it "should include id" do
         obj = klass.new(simple_route, '/project/12345')
-        obj.components.should eql(['project', '12345'])
-        obj.params[:id].should eql('12345')
+        expect(obj.components).to eql(['project', '12345'])
+        expect(obj.params[:id]).to eql('12345')
       end
     end
 
@@ -51,15 +51,15 @@ describe Restfulness::Path do
     context "complex paths" do
       it "should prepare path" do
         obj = klass.new(complex_route, '/project/12345/status')
-        obj.components.should eql(['project', '12345', 'status'])
-        obj.params[:project_id].should eql('12345')
+        expect(obj.components).to eql(['project', '12345', 'status'])
+        expect(obj.params[:project_id]).to eql('12345')
       end
 
       it "should handle end id" do
         obj = klass.new(complex_route, '/project/12345/status/23456')
-        obj.components.should eql(['project', '12345', 'status', '23456'])
-        obj.params[:project_id].should eql('12345')
-        obj.params[:id].should eql('23456')
+        expect(obj.components).to eql(['project', '12345', 'status', '23456'])
+        expect(obj.params[:project_id]).to eql('12345')
+        expect(obj.params[:id]).to eql('23456')
       end
     end
   end
@@ -67,7 +67,7 @@ describe Restfulness::Path do
   describe "#to_s" do
     it "should provide simple string" do
       obj = klass.new(complex_route, '/project/12345/status/23456')
-      obj.to_s.should eql('/project/12345/status/23456')
+      expect(obj.to_s).to eql('/project/12345/status/23456')
     end
   end
 
@@ -76,15 +76,15 @@ describe Restfulness::Path do
       obj = klass.new(complex_route, '/project/12345/status/23456')
     end
     it "should grant access to components by index" do
-      obj[0].should eql('project')
-      obj[1].should eql('12345')
-      obj[2].should eql('status')
-      obj[3].should eql('23456')
-      obj[4].should be_nil
+      expect(obj[0]).to eql('project')
+      expect(obj[1]).to eql('12345')
+      expect(obj[2]).to eql('status')
+      expect(obj[3]).to eql('23456')
+      expect(obj[4]).to be_nil
     end
     it "should grant access to path parameters by symbol" do
-      obj[:project_id].should eql('12345')
-      obj[:id].should eql('23456')
+      expect(obj[:project_id]).to eql('12345')
+      expect(obj[:id]).to eql('23456')
     end
   end