skeleton 0.3.3 → 0.4.1

data/test/integrations/validate_complex_schema_spec.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+require 'multi_json'
+require 'json-schema'
+
+require 'skeleton/serializers/swagger'
+
+describe 'Validate complex schemas' do
+  context 'KISSmetrics Core API' do
+    it 'conforms to the Swagger v2.0 Schema' do
+      # JSON Validator will reach out and grab this draft. This is to avoid
+      # the intermittent errors that occur
+      stub_request(:get, "http://json-schema.org/draft-04/schema")
+        .to_return({
+          status: 200,
+          body: Fixtures.read('json-schema-draft-04.json')
+        })
+
+      structure = KISSmetrics::CoreAPI.structure
+      hash = Skeleton::Serializers::Swagger.new(structure).to_h
+      schema = MultiJson.load(Fixtures.read('schema.json'))
+
+      errors = JSON::Validator.fully_validate(schema, hash, :errors_as_objects => true)
+
+      unless errors.empty?
+        messages = [
+          "JSON Validation Failed",
+          "Errors: #{errors.length}"
+        ]
+
+        errors.each do |e|
+          messages << '  '.concat(e[:message])
+          messages << '    => '.concat(e[:fragment])
+          messages << '    => '.concat(e[:failed_attribute])
+          messages << '    => '.concat(e[:schema])
+          messages << ''
+        end
+
+        fail(messages.join("\n"))
+      end
+    end
+  end
+end

data/test/skeleton/graph_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+require 'skeleton/graph'
+
+module Skeleton
+  class GraphTest < Minitest::Test
+    def test_integration
+      graph = Skeleton::Graph.new
+      graph.register('Accounts', ['Meta', 'AccountData', 'Link'])
+      graph.register('Meta', 'Error')
+      graph.register('Error', 'Error')
+      graph.register('Accounts', 'AccountData')
+      graph.register('AccountData', 'Contact')
+      graph.register('Accounts', 'Link')
+
+      expected = Set.new(%w(Accounts Meta AccountData Link Contact Error))
+      actual = Set.new
+      graph.each_dependent_for('Accounts') { |n| actual.add(n) }
+      assert_equal(expected, actual)
+    end
+  end
+end

data/test/skeleton/mapper_test.rb

@@ -0,0 +1,84 @@
+require 'test_helper'
+
+require 'skeleton'
+
+module Skeleton
+  class MapperTest < Minitest::Test
+
+    def structure
+      @structure ||= Skeleton::Structure.new
+    end
+
+    def setup
+      structure.configure do
+        define_model('Link') do
+          describe('The link object used for api discovery')
+          required(:href,      type: 'string')
+          required(:rel,       type: 'string')
+          optional(:templated, type: 'boolean')
+          optional(:name,      type: 'string')
+        end
+
+        define_model('Error') do
+          describe('Represents an error')
+          required(:message, type: 'string')
+          optional(:field,   type: 'string')
+          optional(:errors,  type: 'array', items: { ref: 'Error' })
+        end
+
+        define_model('Meta') do
+          describe('The meta information regarding the request')
+          required(:status,  type: 'integer')
+          optional(:message, type: 'string')
+          optional(:errors,  type: 'array', items: { ref: 'Error' })
+        end
+
+        define_model('ErrorResponse') do
+          describe('The information when there is an issue with a request')
+          required(:meta, ref: 'Meta')
+          required(:links, type: 'array', items: { ref: 'Link' })
+        end
+
+        define_model('Contact') do
+          optional(:name, type: 'string')
+          optional(:country, type: 'string')
+          optional(:phone, type: 'string')
+        end
+
+        define_model('AccountData') do
+          required(:id,         type: 'string', format: 'uuid')
+          required(:name,       type: 'string')
+          required(:status,     type: 'string', enum: %w(active canceled))
+          required(:created_at, type: 'string', format: 'date-time')
+          required(:updated_at, type: 'string', format: 'date-time')
+          required(:contact,    ref: 'Contact')
+          optional(:links,      type: 'array', items: { ref: 'Link' })
+        end
+
+        define_model('Account') do
+          required(:meta,  ref: 'Meta')
+          required(:data,  ref: 'AccountData')
+          required(:links, type: 'array', items: { ref: 'Link' })
+        end
+
+        define_model('Accounts') do
+          required(:meta,  ref: 'Meta')
+          required(:data,  type: 'array', items: { ref: 'AccountData' })
+          required(:links, type: 'array', items: { ref: 'Link' })
+        end
+
+        define_path('/accounts') do
+          get do
+            response(200) do
+              describe 'get a list of accounts'
+              schema(ref: 'Accounts')
+            end
+          end
+        end
+      end
+    end # end setup
+
+    def test_the_mapping
+    end
+  end
+end

data/test/skeleton/operation_test.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+require 'skeleton/operation'
+
+module Skeleton
+  class OperationTest < Minitest::Test
+    def setup
+      @operation = Skeleton::Operation.new
+    end
+  end
+end

data/test/skeleton/parameter_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+require 'skeleton/parameter'
+
+module Skeleton
+  class ParameterTests < Minitest::Test
+    def parameter
+      @parameter ||= Skeleton::Parameter.new
+    end
+
+    def test_body?
+      parameter.location = 'body'
+      assert(parameter.body?)
+    end
+
+    def test_query?
+      parameter.location = 'query'
+      refute(parameter.body?)
+      assert(parameter.query?)
+    end
+
+    def test_path?
+      parameter.location = 'path'
+      refute(parameter.body?)
+      assert(parameter.path?)
+    end
+
+    def test_header?
+      parameter.location = 'header'
+      refute(parameter.body?)
+      assert(parameter.header?)
+    end
+  end
+end

data/test/skeleton/parameters_test.rb

@@ -0,0 +1,9 @@
+require 'skeleton/parameters'
+
+module Skeleton
+  class ParametersTest < Minitest::Test
+    def setup
+      @parameters = Skeleton::Parameters.new
+    end
+  end
+end

data/test/skeleton/path_test.rb

@@ -0,0 +1,46 @@
+require 'test_helper'
+
+require 'skeleton/path'
+
+module Skeleton
+  class PathTest < Minitest::Test
+    def setup
+      @path = Skeleton::Path.new
+    end
+    def test_get
+      @path.get do
+      end
+      assert(@path.operations.key?(:get), 'expected the get operation to be present')
+    end
+
+    def test_put
+      @path.put do
+      end
+      assert(@path.operations.key?(:put), 'expected the put operation to be present')
+    end
+
+    def test_post
+      @path.post do
+      end
+      assert(@path.operations.key?(:post), 'expected the post operation to be present')
+    end
+
+    def test_patch
+      @path.patch do
+      end
+      assert(@path.operations.key?(:patch), 'expected the patch operation to be present')
+    end
+
+    def test_delete
+      @path.delete do
+      end
+      assert(@path.operations.key?(:delete), 'expected the delete operation to be present')
+    end
+
+    def test_options
+      @path.options do
+      end
+      assert(@path.operations.key?(:options), 'expected the options operation to be present')
+    end
+  end
+end

data/test/skeleton/property_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+require 'skeleton/property'
+
+module Skeleton
+  class PropertyTest < Minitest::Test
+  end
+end

data/test/skeleton/serializers/options_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+
+module Skeleton
+  module Serializers
+    class OptionsTest < Minitest::Test
+      def structure
+        @structure ||= Skeleton::Structure.new
+      end
+
+      def serializer
+        @serializer ||= Skeleton::Serializers::Options.new(structure, path: '/accounts')
+      end
+
+      def test_deeply_nested_dependencies
+        Factories::StructureFactory.configure_basic_structure(structure)
+        hash = serializer.to_h
+
+        refute_nil(hash[:definitions], 'Expected definitions to be present')
+        refute_nil(hash[:definitions]['Accounts'])
+        refute_nil(hash[:definitions]['AccountData'])
+        refute_nil(hash[:definitions]['Meta'])
+        refute_nil(hash[:definitions]['Error'])
+        refute_nil(hash[:definitions]['Link'])
+        refute_nil(hash[:definitions]['Contact'])
+        refute_nil(hash[:definitions]['ErrorResponse'])
+      end
+
+      def test_empty_structure
+        assert_raises(Skeleton::Error) { serializer.to_h }
+      end
+
+      def test_reference_non_existant_model
+        structure.define_path('/accounts') do
+          get do
+            response(200) do
+              schema(ref: 'Foo')
+            end
+          end
+        end
+        structure.define_model('Foo') do
+          property(:bar, type: 'array', items: { ref: 'Bar' })
+        end
+
+        hash = serializer.to_h
+
+        refute_nil(hash[:definitions], 'Expected definitions to be present')
+        refute_nil(hash[:definitions]['Foo'], 'Expected Foo to be present')
+        assert_empty(hash[:definitions]['Bar'], 'Expected Bar to be empty')
+      end
+
+      def test_path_that_does_not_exist
+        structure.define_model('Foo') do
+          property(:bar, type: 'array', items: { ref: 'Bar' })
+        end
+
+        assert_raises(Skeleton::Error) do
+          serializer.to_h
+        end
+      end
+
+      def test_path_not_specified
+        assert_raises(Skeleton::Error) do
+          Skeleton::Serializers::Options.new(structure)
+        end
+      end
+    end
+  end
+end

data/test/skeleton/serializers/swagger_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+module Skeleton
+  module Serializers
+    class SwaggerTest < Minitest::Test
+      def structure
+        @structure ||= Skeleton::Structure.new
+      end
+
+      def serializer
+        @serializer ||= Skeleton::Serializers::Swagger.new(structure)
+      end
+
+      def test_empty_structure
+        result = serializer.to_h
+        assert_equal('2.0', result[:swagger])
+        refute_nil(result[:info], 'expected the info hash to be present')
+
+        assert(result.key?(:basePath))
+        assert(result.key?(:host))
+        assert_empty(result[:schemes])
+        assert_empty(result[:consumes])
+        assert_empty(result[:produces])
+        assert_empty(result[:tags])
+        assert_empty(result[:paths])
+        assert_empty(result[:definitions])
+      end
+    end
+  end
+end

data/test/support/factories/structure_factory.rb

@@ -0,0 +1,86 @@
+require 'skeleton'
+
+module Factories
+  class StructureFactory
+    def self.build_basic_structure
+      structure = Skeleton::Structure.new
+      configure_basic_structure(structure)
+      structure
+    end
+
+    def self.configure_basic_structure(structure)
+      structure.configure do
+        define_model('Link') do
+          describe('The link object used for api discovery')
+          required(:href,      type: 'string')
+          required(:rel,       type: 'string')
+          optional(:templated, type: 'boolean')
+          optional(:name,      type: 'string')
+        end
+
+        define_model('Error') do
+          describe('Represents an error')
+          required(:message, type: 'string')
+          optional(:field,   type: 'string')
+          optional(:errors,  type: 'array', items: { ref: 'Error' })
+        end
+
+        define_model('Meta') do
+          describe('The meta information regarding the request')
+          required(:status,  type: 'integer')
+          optional(:message, type: 'string')
+          optional(:errors,  type: 'array', items: { ref: 'Error' })
+        end
+
+        define_model('ErrorResponse') do
+          describe('The information when there is an issue with a request')
+          required(:meta, ref: 'Meta')
+          required(:links, type: 'array', items: { ref: 'Link' })
+        end
+
+        define_model('Contact') do
+          optional(:name, type: 'string')
+          optional(:country, type: 'string')
+          optional(:phone, type: 'string')
+        end
+
+        define_model('AccountData') do
+          required(:id,         type: 'string', format: 'uuid')
+          required(:name,       type: 'string')
+          required(:status,     type: 'string', enum: %w(active canceled))
+          required(:created_at, type: 'string', format: 'date-time')
+          required(:updated_at, type: 'string', format: 'date-time')
+          required(:contact,    ref: 'Contact')
+          optional(:links,      type: 'array', items: { ref: 'Link' })
+        end
+
+        define_model('Account') do
+          required(:meta,  ref: 'Meta')
+          required(:data,  ref: 'AccountData')
+          required(:links, type: 'array', items: { ref: 'Link' })
+        end
+
+        define_model('Accounts') do
+          required(:meta,  ref: 'Meta')
+          required(:data,  type: 'array', items: { ref: 'AccountData' })
+          required(:links, type: 'array', items: { ref: 'Link' })
+        end
+
+        define_path('/accounts') do
+          get do
+            response(200) do
+              describe 'get a list of accounts'
+              schema(ref: 'Accounts')
+            end
+            response(403) do
+              describe 'access denied'
+              schema(ref: 'ErrorResponse')
+            end
+          end
+        end
+      end
+      structure
+    end
+
+  end
+end