raml_ruby 0.1.1 → 0.1.2

data/test/raml/root_spec.rb

@@ -16,7 +16,7 @@ describe Raml::Root do
   }
 
   subject { Raml::Root.new data }
-  
+
   describe '#new' do
     it "should init root" do
       expect { subject }.to_not raise_error
@@ -30,7 +30,7 @@ describe Raml::Root do
       let(:data) { { 'title' => 1, 'baseUri' => 'x' } }
       it { expect{ subject }.to raise_error Raml::InvalidProperty, /title/ }
     end
-    
+
     context 'when the baseUri property is missing' do
       let(:data) { { 'title' => 'x' } }
       it { expect{ subject }.to raise_error Raml::RequiredPropertyMissing, /baseUri/ }
@@ -72,7 +72,7 @@ describe Raml::Root do
       let(:data) { { 'title' => 'x', 'baseUri' => 'https://api.stormpath.com/}version}' } }
       it { expect{ subject }.to raise_error Raml::InvalidProperty, /baseUri/ }
     end
-    
+
     context 'when the protocols property is missing' do
       let(:data) { { 'title' => 'x', 'baseUri' => 'http://foo.com' } }
       it { expect{ subject }.to_not raise_error }
@@ -108,7 +108,7 @@ describe Raml::Root do
         subject.protocols.should eq [ 'HTTP', 'HTTPS' ]
       end
     end
-    
+
     [
        'application/json',
        'application/x-yaml',
@@ -128,7 +128,7 @@ describe Raml::Root do
       let(:data) { { 'title' => 'x', 'baseUri' => 'http://foo.com', 'media_type' => 'foo' } }
       it { expect{ subject }.to raise_error Raml::InvalidProperty, /mediaType/ }
     end
-    
+
     context 'when the schemas property is an array of maps with string keys and values' do
       let(:data) { { 'title' => 'x', 'baseUri' => 'http://foo.com', 'schemas' => [{'foo'=>'bar'}] } }
       it { expect{ subject }.to_not raise_error }
@@ -175,7 +175,7 @@ describe Raml::Root do
       let(:data) { { 'title' => 'x', 'baseUri' => 'http://foo.com', 'schemas' => [{'foo'=>'bar'},{'foo'=>'boo'}] } }
       it { expect{ subject }.to raise_error Raml::InvalidProperty, /schemas/ }
     end
-  
+
     context 'when the baseUriParameter property is well formed' do
       let(:data) {
         YAML.load(
@@ -231,7 +231,7 @@ describe Raml::Root do
       let(:data) { { 'title' => 'x', 'baseUri' => 'http://foo.com', 'baseUriParameters' => { 'version' => {}} } }
       it { expect { subject }.to raise_error Raml::InvalidProperty, /baseUriParameters/ }
     end
-  
+
     context 'when the documentation parameter is given and valid' do
       let(:data) {
         YAML.load(
@@ -275,7 +275,7 @@ describe Raml::Root do
       let(:data) { { 'title' => 'x', 'baseUri' => 'http://foo.com', 'documentation' => [{'title' => 'x', 'content' => ''}] } }
       it { expect { subject }.to raise_error Raml::InvalidProperty, /document/ }
     end
-    
+
     context 'when top-level resources are defined' do
       let(:data) {
         YAML.load(
@@ -413,6 +413,83 @@ describe Raml::Root do
         it { expect{ subject }.to raise_error Raml::InvalidProperty, /traits/ }
       end
     end
+
+    context 'when the securedBy property is defined' do
+      context 'when the securitySchemes property is an array of strings' do
+        let(:data) { { 'title' => 'x', 'baseUri' => 'http://foo.com', 'securedBy' => ['oauth_2_0', 'oauth_1_0'], 'securitySchemes' => ['oauth_2_0' => {'type' => 'OAuth 2.0'}, 'oauth_1_0' => {'type' => 'OAuth 1.0'}] } }
+        it { expect{ subject }.to_not raise_error }
+      end
+      context 'when the securitySchemes property is an array of strings and "null"' do
+        let(:data) { { 'title' => 'x', 'baseUri' => 'http://foo.com', 'securedBy' => ['oauth_2_0', 'null'], 'securitySchemes' => ['oauth_2_0' => {'type' => 'OAuth 2.0'}] } }
+        it { expect{ subject }.to_not raise_error }
+      end
+      context 'when the securitySchemes property is an array of hash with single key' do
+        let(:data) { { 'title' => 'x', 'baseUri' => 'http://foo.com', 'securedBy' => ['oauth_2_0' => {'scopes' => 'ADMINISTRATOR'}], 'securitySchemes' => ['oauth_2_0' => {'type' => 'OAuth 2.0'}] } }
+        it { expect{ subject }.to_not raise_error }
+      end
+      context 'when the securitySchemes property references a missing security scheme' do
+        let(:data) { { 'title' => 'x', 'baseUri' => 'http://foo.com', 'securedBy' => ['bar'], 'securitySchemes' => ['oauth_2_0' => {'type' => 'OAuth 2.0'}] } }
+        it { expect{ subject }.to raise_error Raml::UnknownSecuritySchemeReference, /bar/}
+      end
+    end
+
+    context 'when the securitySchemes property is defined' do
+      context 'when the securitySchemes property is an array of maps with string keys and and map values' do
+        let(:data) { { 'title' => 'x', 'baseUri' => 'http://foo.com', 'securitySchemes' => [{'foo'=>{},'boo'=>{}}] } }
+        it { expect{ subject }.to_not raise_error }
+      end
+      context 'when the securitySchemes property is an array with a single map' do
+        let(:data) { { 'title' => 'x', 'baseUri' => 'http://foo.com', 'securitySchemes' => [{'foo'=>{}}] } }
+        it 'returns the SecurityScheme in the #security_schemes method' do
+          subject.security_schemes.should be_a Hash
+          subject.security_schemes.keys.should contain_exactly('foo')
+          subject.security_schemes['foo'].should be_a Raml::SecurityScheme
+          subject.security_schemes['foo'].name.should == 'foo'
+        end
+        context 'when the securitySchemes property is an array with a single map with multiple types' do
+          let(:data) { { 'title' => 'x', 'baseUri' => 'http://foo.com', 'securitySchemes' => [{'foo'=>{},'boo'=>{}}] } }
+          it 'returns the SecuritySchemes in the #security_schemes method' do
+            subject.security_schemes.should be_a Hash
+            subject.security_schemes.keys.should contain_exactly('foo', 'boo')
+            subject.security_schemes.values.should all(be_a Raml::SecurityScheme)
+            subject.security_schemes.values.map(&:name).should contain_exactly('foo', 'boo')
+          end
+        end
+      end
+      context 'when the securitySchemes property is an array with multiple maps' do
+        let(:data) { { 'title' => 'x', 'baseUri' => 'http://foo.com', 'securitySchemes' => [{'foo'=>{}},{'boo'=>{}}] } }
+        it 'returns the merged maps in the #security_schemes method' do
+          subject.security_schemes.should be_a Hash
+          subject.security_schemes.keys.should contain_exactly('foo', 'boo')
+          subject.security_schemes.values.should all(be_a Raml::SecurityScheme)
+          subject.security_schemes.values.map(&:name).should contain_exactly('foo', 'boo')
+        end
+      end
+      context 'when the securitySchemes property is not an array' do
+        let(:data) { { 'title' => 'x', 'baseUri' => 'http://foo.com', 'securitySchemes' => 'x' } }
+        it { expect{ subject }.to raise_error Raml::InvalidProperty, /securitySchemes/ }
+      end
+      context 'when the securitySchemes property is an empty array' do
+        let(:data) { { 'title' => 'x', 'baseUri' => 'http://foo.com', 'securitySchemes' => [] } }
+        it { expect{ subject }.to_not raise_error }
+      end
+      context 'when the securitySchemes property is an array with some non-map elements' do
+        let(:data) { { 'title' => 'x', 'baseUri' => 'http://foo.com', 'securitySchemes' => [{'foo'=>{}}, 1] } }
+        it { expect{ subject }.to raise_error Raml::InvalidProperty, /securitySchemes/ }
+      end
+      context 'when the securitySchemes property is an array of maps with non-string keys' do
+        let(:data) { { 'title' => 'x', 'baseUri' => 'http://foo.com', 'securitySchemes' => [{1=>{}}] } }
+        it { expect{ subject }.to raise_error Raml::InvalidProperty, /securitySchemes/ }
+      end
+      context 'when the securitySchemes property is an array of maps with non-map values' do
+        let(:data) { { 'title' => 'x', 'baseUri' => 'http://foo.com', 'securitySchemes' => [{'foo'=>1}] } }
+        it { expect{ subject }.to raise_error Raml::InvalidProperty, /securitySchemes/ }
+      end
+      context 'when the securitySchemes property has duplicate type names' do
+        let(:data) { { 'title' => 'x', 'baseUri' => 'http://foo.com', 'securitySchemes' => [{'foo'=>{}},{'foo'=>{}}] } }
+        it { expect{ subject }.to raise_error Raml::InvalidProperty, /securitySchemes/ }
+      end
+    end
   end
 
   describe '#expand' do
@@ -642,14 +719,4 @@ describe Raml::Root do
       end
     end
   end
-
-  describe '#document' do
-    it 'returns a String' do
-      subject.document.should be_a String
-    end
-    it 'should render the template' do
-      mock(Slim::Template).new(/templates\/root.slim\z/, is_a(Hash)).mock!.render(is_a(Raml::Node)) { '' }
-      subject.document
-    end
-  end
 end

data/test/raml/security_scheme_spec.rb

@@ -0,0 +1,71 @@
+# encoding: UTF-8
+require_relative 'spec_helper'
+
+describe Raml::SecurityScheme do
+  let(:name) { 'oauth_2_0' }
+  let(:data) {
+    YAML.load(%q(
+      description: |
+          Dropbox supports OAuth 2.0 for authenticating all API requests.
+      type: OAuth 2.0
+      describedBy:
+          headers:
+              Authorization:
+                  description: |
+                      Used to send a valid OAuth 2 access token. Do not use
+                      with the "access_token" query string parameter.
+                  type: string
+          queryParameters:
+              access_token:
+                  description: |
+                      Used to send a valid OAuth 2 access token. Do not use together with
+                      the "Authorization" header
+                  type: string
+          responses:
+              401:
+                  description: |
+                      Bad or expired token. This can happen if the user or Dropbox
+                      revoked or expired an access token. To fix, you should re-
+                      authenticate the user.
+              403:
+                  description: |
+                      Bad OAuth request (wrong consumer key, bad nonce, expired
+                      timestamp...). Unfortunately, re-authenticating the user won't help here.
+      settings:
+          authorizationUri: https://www.dropbox.com/1/oauth2/authorize
+          accessTokenUri: https://api.dropbox.com/1/oauth2/token
+          authorizationGrants: [ code, token ]
+    ))
+  }
+  let(:root) { Raml::Root.new 'title' => 'x', 'baseUri' => 'http://foo.com' }
+
+  subject { Raml::SecurityScheme.new(name, data, root) }
+
+  describe '#new' do
+    context 'with valid arguments' do
+      it { expect { subject }.to_not raise_error }
+      it { should be_a Raml::SecurityScheme }
+    end
+  end
+
+  describe '#instantiate' do
+    context 'when the description property is given' do
+      before { data['description'] = 'Some text' }
+      it 'stores the description property' do
+        subject.instantiate({}).description.should eq data['description']
+      end
+    end
+    context 'when the type property is given' do
+      before { data['type'] = 'Some text' }
+      it 'stores the type property' do
+        subject.instantiate({}).type.should eq data['type']
+      end
+    end
+    context 'with invalid arguments' do
+      context 'when the securityScheme has nested resources' do
+        before { data['/foo'] = {} }
+        it { expect { subject.instantiate({}) }.to raise_error Raml::UnknownProperty, /\/foo/ }
+      end
+    end
+  end
+end

data/test/raml/spec_helper.rb

@@ -1,9 +1,10 @@
 require_relative '../../lib/raml'
 require 'pry'
 require 'yaml'
+require 'json'
 
 RSpec.configure do |config|
- 	config.expect_with :rspec do |c|
+   config.expect_with :rspec do |c|
     c.syntax = [:should, :expect]
   end
   config.mock_framework = :rr

data/test/raml/template_spec.rb

@@ -3,96 +3,96 @@ require_relative 'spec_helper'
 describe Raml::Template do
   let(:root) { Raml::Root.new 'title' => 'x', 'baseUri' => 'http://foo.com' }
 
-	describe '#new' do
-	end
+  describe '#new' do
+  end
 
-	describe '#interpolate' do
-		subject { Raml::Template.new('foo', data, root).interpolate params }
-		context 'when the data requires no parameters' do
-			let(:params) { {} }
-			context 'when its a shallow object' do
-				let(:data  ) { {'aaa' => 'bbb', 'ccc' => 'ddd', 'eee' => 'fff' } }
-				it 'returns the same data that was inputted' do
-					subject[1].should eq data
-				end
-			end
-			context 'when its a nested object' do
-			let(:data  ) { {'aaa' => 'bbb', 'ccc' => [ 'ddd', 'eee' ], 'fff' => { 'ggg' => 'hhh', 'iii' => ['jjj'] } } }
-				it 'returns the same data that was inputted' do
-					subject[1].should eq data
-				end
-			end
-		end
-		context 'when the data requires parameters' do
-			context 'when its a shallow object' do
-				let(:data  ) { {'aaa <<foo>>' => 'bbb', 'ccc' => '<<bar>> ddd', 'eee' => 'fff' } }
-				context 'when a required parameter is missing' do
-					let(:params) { { 'foo' => 'bar' } }
-					it do
-						expect { subject }.to raise_exception Raml::UnknownTypeOrTraitParameter
-					end
-				end
-				context 'when all parameters are given' do
-					let(:params) { { 'foo' => 'bar', 'bar' => 'baz' } }
-					it 'returns the name with the parameter interpolated' do
-						subject[1].should eq ({'aaa bar' => 'bbb', 'ccc' => 'baz ddd', 'eee' => 'fff' })
-					end
-				end
-			end
-			context 'when its a nested object' do
-			let(:data  ) { {'aaa <<foo>>' => 'bbb', 'ccc' => [ '<<bar>> ddd', 'eee' ], 'fff' => { 'ggg' => 'hhh', '<<baz>> iii' => ['<<jaz>> jjj'] } } }
-				context 'when a required parameter is missing' do
-					let(:params) { { 'foo' => 'bar' } }
-					it do
-						expect { subject }.to raise_exception Raml::UnknownTypeOrTraitParameter
-					end
-				end
-				context 'when all parameters are given' do
-					let(:params) { { 'foo' => 'bar', 'bar' => 'baz', 'baz' => 'jaz', 'jaz' => 'max' } }
-					it 'returns the name with the parameter interpolated' do
-						subject[1].should eq ({'aaa bar' => 'bbb', 'ccc' => [ 'baz ddd', 'eee' ], 'fff' => { 'ggg' => 'hhh', 'jaz iii' => ['max jjj'] } })
-					end
-				end
-			end
-		end
-		context 'when function parameters are used' do
-			context 'when the function is not known' do
-				let(:params) { {'some_param' => 'test'} }
-				let(:data  ) { {'bar' => '<<some_param | !unknown>>'} }
-				it do
-					expect { subject }.to raise_exception Raml::UnknownTypeOrTraitParamFunction
-				end
-			end
-			context 'when the function is singularize' do
-				let(:data) { {'bar' => 'some <<some_param | !singularize>>'} }
-				context 'when the parameter is plural' do
-					let(:params) { {'some_param' => 'tests'} }
-					it 'signularizes it' do
-						subject[1]['bar'].should eq  'some test'
-					end
-				end
-				context 'when the parameter is singular' do
-					let(:params) { {'some_param' => 'test'} }
-					it 'keeps it singular' do
-						subject[1]['bar'].should eq  'some test'
-					end
-				end
-			end
-			context 'when the function is pluralize' do
-				let(:data) { {'bar' => 'some <<some_param | !pluralize>>'} }
-				context 'when the parameter is singular' do
-					let(:params) { {'some_param' => 'test'} }
-					it 'pluralizes it' do
-						subject[1]['bar'].should eq  'some tests'
-					end
-				end
-				context 'when the parameter is plural' do
-					let(:params) { {'some_param' => 'tests'} }
-					it 'keeps it plural' do
-						subject[1]['bar'].should eq  'some tests'
-					end
-				end
-			end
-		end
-	end
-end
+  describe '#interpolate' do
+    subject { Raml::Template.new('foo', data, root).interpolate params }
+    context 'when the data requires no parameters' do
+      let(:params) { {} }
+      context 'when its a shallow object' do
+        let(:data  ) { {'aaa' => 'bbb', 'ccc' => 'ddd', 'eee' => 'fff' } }
+        it 'returns the same data that was inputted' do
+          subject[1].should eq data
+        end
+      end
+      context 'when its a nested object' do
+      let(:data  ) { {'aaa' => 'bbb', 'ccc' => [ 'ddd', 'eee' ], 'fff' => { 'ggg' => 'hhh', 'iii' => ['jjj'] } } }
+        it 'returns the same data that was inputted' do
+          subject[1].should eq data
+        end
+      end
+    end
+    context 'when the data requires parameters' do
+      context 'when its a shallow object' do
+        let(:data  ) { {'aaa <<foo>>' => 'bbb', 'ccc' => '<<bar>> ddd', 'eee' => 'fff' } }
+        context 'when a required parameter is missing' do
+          let(:params) { { 'foo' => 'bar' } }
+          it do
+            expect { subject }.to raise_exception Raml::UnknownTypeOrTraitParameter
+          end
+        end
+        context 'when all parameters are given' do
+          let(:params) { { 'foo' => 'bar', 'bar' => 'baz' } }
+          it 'returns the name with the parameter interpolated' do
+            subject[1].should eq ({'aaa bar' => 'bbb', 'ccc' => 'baz ddd', 'eee' => 'fff' })
+          end
+        end
+      end
+      context 'when its a nested object' do
+      let(:data  ) { {'aaa <<foo>>' => 'bbb', 'ccc' => [ '<<bar>> ddd', 'eee' ], 'fff' => { 'ggg' => 'hhh', '<<baz>> iii' => ['<<jaz>> jjj'] } } }
+        context 'when a required parameter is missing' do
+          let(:params) { { 'foo' => 'bar' } }
+          it do
+            expect { subject }.to raise_exception Raml::UnknownTypeOrTraitParameter
+          end
+        end
+        context 'when all parameters are given' do
+          let(:params) { { 'foo' => 'bar', 'bar' => 'baz', 'baz' => 'jaz', 'jaz' => 'max' } }
+          it 'returns the name with the parameter interpolated' do
+            subject[1].should eq ({'aaa bar' => 'bbb', 'ccc' => [ 'baz ddd', 'eee' ], 'fff' => { 'ggg' => 'hhh', 'jaz iii' => ['max jjj'] } })
+          end
+        end
+      end
+    end
+    context 'when function parameters are used' do
+      context 'when the function is not known' do
+        let(:params) { {'some_param' => 'test'} }
+        let(:data  ) { {'bar' => '<<some_param | !unknown>>'} }
+        it do
+          expect { subject }.to raise_exception Raml::UnknownTypeOrTraitParamFunction
+        end
+      end
+      context 'when the function is singularize' do
+        let(:data) { {'bar' => 'some <<some_param | !singularize>>'} }
+        context 'when the parameter is plural' do
+          let(:params) { {'some_param' => 'tests'} }
+          it 'signularizes it' do
+            subject[1]['bar'].should eq  'some test'
+          end
+        end
+        context 'when the parameter is singular' do
+          let(:params) { {'some_param' => 'test'} }
+          it 'keeps it singular' do
+            subject[1]['bar'].should eq  'some test'
+          end
+        end
+      end
+      context 'when the function is pluralize' do
+        let(:data) { {'bar' => 'some <<some_param | !pluralize>>'} }
+        context 'when the parameter is singular' do
+          let(:params) { {'some_param' => 'test'} }
+          it 'pluralizes it' do
+            subject[1]['bar'].should eq  'some tests'
+          end
+        end
+        context 'when the parameter is plural' do
+          let(:params) { {'some_param' => 'tests'} }
+          it 'keeps it plural' do
+            subject[1]['bar'].should eq  'some tests'
+          end
+        end
+      end
+    end
+  end
+end

data/test/raml/trait_spec.rb

@@ -1,7 +1,7 @@
 require_relative 'spec_helper'
 
 describe Raml::Trait do
-	let(:name) { 'secured' }
+  let(:name) { 'secured' }
   let(:data) {
     YAML.load(%q(
       usage: Apply this to any method that needs to be secured
@@ -19,13 +19,13 @@ describe Raml::Trait do
   subject { Raml::Trait.new name, data, root }
 
   describe '#new' do
-  	context 'when the trait name is not an HTTP method name' do
+    context 'when the trait name is not an HTTP method name' do
       it { expect { subject }.to_not raise_error }
     end
     context 'when the usage property is given' do
-	    it 'stores the usage property' do
-	    	subject.instantiate({}).usage.should eq data['usage']
-	    end
-	  end
+      it 'stores the usage property' do
+        subject.instantiate({}).usage.should eq data['usage']
+      end
+    end
   end
-end
+end