atum 0.5.0

data/spec/atum/generation/generator_resource_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Atum::Generation::GeneratorResource do
+  let(:resource_schema) do
+    instance_double('Atum::Core::Schema::ResourceSchema',
+                    name: 'super-awesome-resource',
+                    description: 'really great',
+                    link_schemas: [double, double, double])
+  end
+  let(:generator_resource) { described_class.new(resource_schema) }
+
+  describe '#name' do
+    subject { generator_resource.name }
+    it 'should delegate to the resource schema' do
+      expect(generator_resource.name).to eq('super_awesome_resource')
+    end
+  end
+
+  describe '#description' do
+    subject { generator_resource.description }
+    it { is_expected.to eq(resource_schema.description) }
+  end
+
+  describe '#links' do
+    subject(:method) { -> {} }
+
+    it 'should create a GeneratorLink for each link schema' do
+      expect(Atum::Generation::GeneratorLink).to receive(:new).exactly(3).times
+      generator_resource.links
+    end
+
+    it 'should return an Array of GeneratorLinks' do
+      generator_resource.links.each do |link|
+        expect(link).to be_a(Atum::Generation::GeneratorLink)
+      end
+    end
+
+    it 'should memoize' do
+      expect(resource_schema).to receive(:link_schemas).once
+      generator_resource.links
+      generator_resource.links
+    end
+  end
+end

data/spec/atum/generation/generator_service_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Atum::Generation::GeneratorService do
+  let(:module_name) { 'Fruity' }
+  let(:schema_file) do
+    File.expand_path('../../fixtures/fruity_schema.json', File.dirname(__FILE__))
+  end
+  let(:url) { 'http://api.fruity.com' }
+  let(:options) { { path: File.join(tmp_folder, 'client') } }
+  let(:generator_service) do
+    described_class.new(module_name, schema_file, url, options)
+  end
+
+  def test_client_file(*args)
+    File.file?(File.join(options[:path], 'fruity', *args))
+  end
+
+  describe '#generate_files' do
+    let(:tmp_folder) do
+      File.expand_path(File.join('..', '..', '..', 'tmp'), File.dirname(__FILE__))
+    end
+    before { FileUtils.mkdir_p options[:path] }
+
+    it 'should create the required folders' do
+      generator_service.generate_files
+      expect(File.directory?(File.join(options[:path], 'fruity'))).to be_truthy
+      expect(File.directory?(File.join(options[:path], 'fruity/resources'))).to be_truthy
+    end
+
+    it 'should create a root client file' do
+      generator_service.generate_files
+      expect(File.file?(File.join(options[:path], 'fruity', 'client.rb'))).to be_truthy
+    end
+
+    it 'should create resource files' do
+      generator_service.generate_files
+      expect(test_client_file('resources', 'lemon.rb')).to be_truthy
+      expect(test_client_file('resources', 'lime.rb')).to be_truthy
+    end
+  end
+end

data/spec/atum/generation/generators/base_generator_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Atum::Generation::Generators::BaseGenerator do
+  let(:module_name) { 'Lemon' }
+  let(:schema) { instance_double('ApiSchema') }
+  let(:url) { 'http://api.lemon.com' }
+  let(:options) { {} }
+  let(:generator) { described_class.new(module_name, schema, url, options) }
+
+  describe '#context' do
+    let(:erb_context) { {} }
+
+    before do
+      allow(generator).to receive(:context_hash).and_return(erb_context)
+    end
+
+    it 'generates a new ErbContext' do
+      expect(Atum::Generation::ErbContext).to receive(:new)
+      generator.context
+    end
+
+    it 'sets the module name' do
+      expect(generator.context.to_hash.with_indifferent_access)
+        .to include(module_name: module_name)
+    end
+  end
+
+  describe '#template' do
+    context 'when TEMPLATE_NAME is not defined' do
+      subject(:method) { -> { generator.template } }
+      it { is_expected.to raise_error(NotImplementedError) }
+    end
+
+    context 'when TEMPLATE_NAME is defined' do
+      let(:template_name) { 'foobar' }
+      before do
+        allow(generator).to receive(:template_name).and_return(template_name)
+      end
+
+      it 'should attempt to read the file' do
+        expect(File).to receive(:read) do |arg|
+          expect(arg).to include(template_name)
+        end.and_return(nil)
+        generator.template
+      end
+
+      it 'should send the opened file through Erubis' do
+        file = double
+        allow(File).to receive(:read).and_return(file)
+        expect(Erubis::Eruby).to receive(:new).with(file)
+        generator.template
+      end
+    end
+  end
+
+  describe '#generate' do
+    it 'evaluates the template with the context' do
+      template = double
+      context = double
+      allow(generator).to receive(:template).and_return(template)
+      allow(generator).to receive(:context).and_return(context)
+      expect(template).to receive(:evaluate).with(context)
+      generator.generate
+    end
+  end
+
+  describe '#resources' do
+    it 'wraps resources with GeneratorResource objects' do
+      allow(schema).to receive(:resource_schemas).and_return([double])
+      generator.resources.each do |gr|
+        expect(gr).to be_a(Atum::Generation::GeneratorResource)
+      end
+    end
+  end
+end

data/spec/atum/generation/generators/client_generator_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Atum::Generation::Generators::ClientGenerator do
+  let(:module_name) { 'Lemon' }
+  let(:schema) { double }
+  let(:url) { 'http://api.lemon.com' }
+  let(:options) { {} }
+  let(:generator) { described_class.new(module_name, schema, url, options) }
+
+  describe '#context' do
+    let(:erb_context) { {} }
+    let(:resources) { double }
+    let(:description) { double }
+    let(:schema) { double(description: description) }
+
+    before do
+      allow(generator).to receive(:resources).and_return(resources)
+    end
+
+    it 'sets the description on the context' do
+      expect(generator.context.to_hash.with_indifferent_access)
+        .to include(description: description)
+    end
+
+    it 'sets the resources on the context' do
+      expect(generator.context.to_hash.with_indifferent_access)
+        .to include(resources: resources)
+    end
+  end
+end

data/spec/atum/generation/generators/module_generator_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Atum::Generation::Generators::ModuleGenerator do
+  let(:module_name) { 'Lemon' }
+  let(:schema) { instance_double('Atum::Schema::ApiSchema') }
+  let(:url) { 'http://api.lemon.com' }
+  let(:default_headers) { double }
+  let(:options) { { default_headers: default_headers } }
+  let(:generator) { described_class.new(module_name, schema, url, options) }
+
+  describe '#context' do
+    let(:erb_context) { {} }
+    let(:resources) { double }
+    let(:description) { double }
+    let(:schema) { double(description: description, schema: {}) }
+
+    before do
+      allow(generator).to receive(:resources).and_return(resources)
+    end
+
+    it 'sets the default_headers on the context' do
+      expect(generator.context.to_hash.with_indifferent_access)
+        .to include(default_headers: default_headers)
+    end
+
+    it 'sets the schema on the context' do
+      expect(generator.context.to_hash.with_indifferent_access)
+        .to include(schema: anything)
+    end
+
+    it 'sets the resources on the context' do
+      allow(generator).to receive(:resources).and_return(resources)
+      expect(generator.context.to_hash.with_indifferent_access)
+        .to include(resources: resources)
+    end
+  end
+end

data/spec/atum/generation/generators/resource_generator_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Atum::Generation::Generators::ResourceGenerator do
+  let(:description) { double }
+  let(:class_name) { double }
+  let(:links) { double }
+  let(:resource_name) { double }
+  let(:resource) do
+    double(description: description,
+           class_name: class_name,
+           links: links,
+           name: resource_name)
+  end
+  let(:module_name) { 'Lemon' }
+  let(:schema) { double }
+  let(:url) { 'http://api.lemon.com' }
+  let(:default_headers) { double }
+  let(:options) { { default_headers: default_headers } }
+  let(:generator) do
+    described_class.new(resource, module_name, schema, url, options)
+  end
+
+  describe '#context' do
+    let(:erb_context) { {} }
+
+    it 'sets the description on the context' do
+      expect(generator.context.to_hash.with_indifferent_access)
+        .to include(description: description)
+    end
+
+    it 'sets the class_name on the context' do
+      expect(generator.context.to_hash.with_indifferent_access)
+        .to include(class_name: class_name)
+    end
+
+    it 'sets the links on the context' do
+      expect(generator.context.to_hash.with_indifferent_access)
+        .to include(links: links)
+    end
+
+    it 'sets the resource_name on the context' do
+      expect(generator.context.to_hash.with_indifferent_access)
+        .to include(resource_name: resource_name)
+    end
+  end
+end

data/spec/atum/generation/options_parameter_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Atum::Generation::OptionsParameter do
+  let(:name) { 'options' }
+  let(:description) { 'any query parameters in the form of a hash' }
+  subject(:parameter) { described_class.new }
+
+  describe '#name' do
+    subject { parameter.name }
+    it { is_expected.to eq(name) }
+  end
+
+  describe '#description' do
+    subject { parameter.description }
+    it { is_expected.to eq(description) }
+  end
+
+  describe '#inspect' do
+    subject { parameter.inspect }
+    it { is_expected.to eq("Parameter(name=#{name}, description=#{description})") }
+  end
+
+  describe '#default' do
+    subject { parameter.default }
+    it { is_expected.to eq('{}') }
+  end
+end

data/spec/fixtures/fruity_schema.json

@@ -0,0 +1,161 @@
+{
+  "description": "A schema for a Fruity API",
+  "definitions": {
+    "lemon": {
+      "description": "For lovers of lemons, look no further.",
+      "id": "schema/lemon",
+      "$schema": "http://json-schema.org/draft-04/hyper-schema",
+      "title": "Lemons",
+      "type": ["object"],
+      "definitions": {
+        "picked_on": {
+          "description": "The date on which the lemon was picked",
+          "example": "2013-10-19 22:10:29Z",
+          "format": "date-time",
+          "readOnly": true,
+          "type": ["string"]
+        },
+        "size": {
+          "description": "The size of the lemon, 'small', 'medium' or 'large'",
+          "example": "small",
+          "readOnly": true,
+          "enum": ["small", "medium", "large"]
+        },
+        "is_ripe": {
+          "description": "Whether or not the lemon is ripe",
+          "example": true,
+          "type": ["boolean"]
+        },
+        "lemon_uuid": {
+          "description": "A unique uuid reference for the lemon",
+          "example": "44724831-bf66-4bc2-865f-e2c4c2b14c78",
+          "format": "uuid",
+          "readOnly": true,
+          "type": ["string"]
+        },
+        "identity": {
+          "oneOf": [
+            { "$ref": "#/definitions/lemon/definitions/lemon_uuid" }
+          ]
+        }
+      },
+      "properties": {
+        "picked_on": { "$ref": "#/definitions/lemon/definitions/picked_on" },
+        "size": { "$ref": "#/definitions/lemon/definitions/size" },
+        "is_ripe": { "$ref": "#/definitions/lemon/definitions/is_ripe" },
+        "lemon_uuid": { "$ref": "#/definitions/lemon/definitions/lemon_uuid" }
+      },
+      "links": [
+        {
+          "description": "List all Lemons",
+          "href": "/lemon",
+          "method": "GET",
+          "rel": "instances",
+          "title": "List",
+          "schema": {
+            "type": ["object"],
+            "properties": {
+              "size": {
+                "type": ["array", "string"],
+                "items": { "$ref": "#/definitions/lemon/definitions/size" },
+                "maxItems": 2
+              }
+            },
+            "additionalProperties": false
+          }
+        },
+        {
+          "description": "Show a single Lemon",
+          "href": "/lemon/{(%23%2Fdefinitions%2Flemon%2Fdefinitions%2Flemon_uuid)}",
+          "method": "GET",
+          "rel": "self",
+          "title": "Info"
+        },
+        {
+          "description": "Create a new Lemon",
+          "href": "/lemon",
+          "method": "POST",
+          "rel": "create",
+          "title": "Create",
+          "schema": {
+            "properties": {
+              "picked_on": { "$ref": "#/definitions/lemon/definitions/picked_on" },
+              "size": { "$ref": "#/definitions/lemon/definitions/size" },
+              "is_ripe": { "$ref": "#/definitions/lemon/definitions/is_ripe" },
+              "lemon_uuid": { "$ref": "#/definitions/lemon/definitions/lemon_uuid" }
+            }
+          }
+        },
+        {
+          "description": "Update a sample lemon",
+          "href": "/lemon/{(%23%2Fdefinitions%2Flemon%2Fdefinitions%2Flemon_uuid)}",
+          "method": "PATCH",
+          "rel": "update",
+          "title": "Update",
+          "schema": {
+            "properties": {
+              "picked_on": { "$ref": "#/definitions/lemon/definitions/picked_on" },
+              "size": { "$ref": "#/definitions/lemon/definitions/size" },
+              "is_ripe": { "$ref": "#/definitions/lemon/definitions/is_ripe" },
+              "lemon_uuid": { "$ref": "#/definitions/lemon/definitions/lemon_uuid" }
+            }
+          }
+        },
+        {
+          "description": "Delete a whole size of lemons, you murderer",
+          "href": "/lemon/{(%23%2Fdefinitions%2Flemon%2Fdefinitions%2Fsize)}",
+          "method": "DELETE",
+          "rel": "destroy",
+          "title": "Delete"
+        }
+      ]
+    },
+    "lime": {
+      "description": "Like lemons, but not as good",
+      "id": "schema/lime",
+      "$schema": "http://json-schema.org/draft-04/hyper-schema",
+      "title": "Limes < Lemons",
+      "type": ["object"],
+      "definitions": {
+        "picked_on": {
+          "description": "The date on which the lime was picked",
+          "example": "2013-10-19 22:10:29Z",
+          "format": "date-time",
+          "readOnly": true,
+          "type": ["string"]
+        },
+        "lime_uuid": {
+          "description": "A unique uuid reference for the lime",
+          "example": "44724831-bf66-4bc2-865f-e2c4c2b14c78",
+          "format": "uuid",
+          "readOnly": true,
+          "type": ["string"]
+        },
+        "identity": {
+          "oneOf": [
+            { "$ref": "#/definitions/lime/definitions/lime_uuid" }
+          ]
+        }
+      },
+      "properties": {
+        "picked_on": { "$ref": "#/definitions/lime/definitions/picked_on" },
+        "lime_uuid": { "$ref": "#/definitions/lime/definitions/lime_uuid" }
+      },
+      "links": [
+        {
+          "description": "List all Limes",
+          "href": "/lime",
+          "method": "GET",
+          "rel": "instances",
+          "title": "List"
+        }
+      ]
+    }
+  },
+  "properties": {
+    "lemon": { "$ref": "#/definitions/lemon" },
+    "lime": { "$ref": "#/definitions/lime" }
+  }
+}
+
+