atum 0.5.0

data/spec/atum/core/resource_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Atum::Core::Resource do
+  let(:method_name) { 'known_method' }
+  let(:links) { { "#{method_name}" => nil } }
+  let(:resource) { described_class.new(links) }
+  let(:resource_schema) do
+    Atum::Core::Schema::ApiSchema.new(SAMPLE_SCHEMA).resource_schema_for('resource')
+  end
+
+  describe '#respond_to?' do
+    subject { resource.respond_to?(method_name) }
+
+    context 'when a link for the method exists' do
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when a link is missing for the method' do
+      let(:links) { {} }
+      it { is_expected.to be_falsey }
+    end
+  end
+
+  describe 'calling a method on the resource' do
+    let(:args) { double }
+    subject(:method) { -> { resource.send(method_name, args) } }
+
+    context 'when a link for the method exists' do
+      let(:link) { double(run: nil) }
+      let(:links) { { "#{method_name}" => link } }
+
+      it 'should send message :run to the link' do
+        expect(link).to receive(:run).with(args)
+        method.call
+      end
+    end
+
+    context 'when a link is missing for the method' do
+      let(:links) { {} }
+      it { is_expected.to raise_error(NoMethodError) }
+    end
+  end
+
+  # it 'raises on invalid link' do
+  #   expect { resource.unknown }
+  #     .to raise_error(NoMethodError,
+  #                     "undefined method `unknown' for #<Atum::Core::Resource")
+  # end
+
+  # context 'when a link is available' do
+  #   let(:link) do
+  #     Atum::Core::Link.new('https://username:password@example.com',
+  #                    schema_resource.link_schema('list'))
+  #   end
+  #   let(:params) { { 'list' => link } }
+  #   let(:response_body) { { 'resources' => ['Hello, world!'] } }
+
+  #   it 'gets the link' do
+  #     stub_request(:get, 'https://username:password@example.com/resource')
+  #       .to_return(status: 200, body: response_body.to_json,
+  #                 headers: { 'Content-Type' => 'application/json' })
+
+  #     expect(resource.list({})).to eq(['Hello, world!'])
+  #   end
+  # end
+end

data/spec/atum/core/response_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+describe Atum::Core::Response do
+  let(:response) { anything }
+  let(:api_response) { described_class.new(response) }
+
+  describe '#body' do
+    subject(:body) { api_response.body }
+
+    context 'when the response is json' do
+      let(:response_body) { { name: 'thing', description: 'awesome thing' } }
+      let(:response) do
+        double(headers: { 'Content-Type' => 'application/json' },
+               body: { 'thing' => response_body }.to_json,
+               status: 200)
+      end
+
+      it { is_expected.to be_a(Hash) }
+    end
+
+    context 'when the response is not json' do
+      let(:response_body) { 'FOOBARBAZ' }
+      let(:response) do
+        double(headers: { 'Content-Type' => 'application/text' },
+               body: 'FOOBARBAZ', status: 200)
+      end
+
+      it 'should come through raw' do
+        expect(body).to eq(response_body)
+      end
+    end
+  end
+
+  describe '#json?' do
+    subject { api_response.json? }
+
+    let(:response) { double(headers: { 'Content-Type' => content_type }) }
+
+    context 'when the response is json' do
+      let(:content_type) { 'application/json' }
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when the response is not json' do
+      let(:content_type) { 'application/text' }
+      it { is_expected.to be_falsey }
+    end
+  end
+
+  describe 'error?' do
+    subject { api_response.error? }
+
+    let(:response) { double(status: status) }
+
+    context 'when the response is an error' do
+      let(:status) { 401 }
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when the response is not an error' do
+      let(:status) { 200 }
+      it { is_expected.to be_falsey }
+    end
+  end
+
+  shared_examples_for 'it needs the response to be json' do
+    context 'when the response is not json' do
+      before { allow(api_response).to receive(:json?) { false } }
+      it { is_expected.to raise_error(Atum::Core::ResponseError) }
+    end
+  end
+
+  describe 'meta' do
+    subject(:method) { -> { api_response.meta } }
+
+    it_behaves_like 'it needs the response to be json'
+
+    context 'when the response is json' do
+      before do
+        allow(api_response).to receive(:json?) { true }
+        allow(api_response).to receive(:json_body) { body }
+      end
+      subject { method.call }
+      let(:meta) { double }
+
+      context 'when meta is present' do
+        let(:body) { { 'meta' => meta } }
+        it { is_expected.to eq(meta) }
+      end
+
+      context 'when meta is not present' do
+        let(:body) { {} }
+        it { is_expected.to eq({}) }
+      end
+    end
+  end
+
+  describe 'limit' do
+    subject(:method) { -> { api_response.limit } }
+
+    it_behaves_like 'it needs the response to be json'
+
+    context 'when the response is json' do
+      before do
+        allow(api_response).to receive(:json?) { true }
+        allow(api_response).to receive(:json_body) { body }
+      end
+      subject { method.call }
+      let(:limit) { double }
+
+      context 'and limit is present' do
+        let(:body) { { 'meta' => { 'limit' => limit } } }
+        it { is_expected.to eq(limit) }
+      end
+
+      context 'and limit is not present' do
+        let(:body) { { 'meta' => {} } }
+        it { is_expected.to eq(nil) }
+      end
+
+      context 'and meta is not present' do
+        let(:body) { {} }
+        it { is_expected.to eq(nil) }
+      end
+    end
+  end
+end

data/spec/atum/core/schema/api_schema_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Atum::Core::Schema::ApiSchema do
+  let(:schema) { described_class.new(SAMPLE_SCHEMA) }
+
+  describe '#description' do
+    it 'returns the schema description' do
+      expect(schema.description).to eq(SAMPLE_SCHEMA['description'])
+    end
+  end
+
+  describe '#resource_schema_for' do
+    it 'has name' do
+      expect(schema.resource_schema_for('resource').name).to eq('resource')
+    end
+
+    it 'raises with unknown resources' do
+      expect { schema.resource_schema_for('lolno') }
+        .to raise_error(Atum::Core::SchemaError)
+    end
+  end
+
+  describe '#resource_schemas' do
+    it 'has several resource schemas' do
+      expect(schema.resource_schemas.map(&:name))
+        .to eq(%w(resource another-resource))
+    end
+  end
+
+  describe '#inspect' do
+    it 'includes description' do
+      expect(schema.inspect).to include(SAMPLE_SCHEMA['description'])
+    end
+  end
+
+  describe '#lookup_path' do
+    it 'returns whole schema for empty path' do
+      expect(schema.lookup_path).to eq(SAMPLE_SCHEMA)
+    end
+
+    it 'fetches values at nested keys' do
+      expect(schema.lookup_path('definitions', 'another-resource', 'id'))
+        .to eq('schema/another-resource')
+
+      expect(schema.lookup_path('definitions', 'resource'))
+        .to eq(SAMPLE_SCHEMA['definitions']['resource'])
+    end
+  end
+end

data/spec/atum/core/schema/link_schema_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Atum::Core::Schema::LinkSchema do
+  let(:schema) { Atum::Core::Schema::ApiSchema.new(SAMPLE_SCHEMA) }
+  let(:resource) { schema.resource_schema_for('resource') }
+  let(:list) { resource.link_schema_for('list') }
+  let(:info) { resource.link_schema_for('info') }
+  let(:identify) { resource.link_schema_for('identify_resource') }
+  let(:create) { resource.link_schema_for('create') }
+  let(:update) { resource.link_schema_for('update') }
+
+  describe '#name' do
+    it 'returns the name' do
+      expect(list.name).to eq('list')
+    end
+  end
+
+  describe '#description' do
+    it 'returns the link description' do
+      expect(list.description).to eq('Show all sample resources')
+    end
+  end
+
+  describe '#method' do
+    it 'returns the link method' do
+      expect(list.method).to eq(:get)
+    end
+  end
+
+  describe '#needs_request_body?' do
+    subject { link_schema.needs_request_body? }
+
+    context 'when link_schema has a schema' do
+      let(:link_schema) { create }
+      it { is_expected.to be_truthy }
+    end
+
+    context "when link_schema doesn't have a schema" do
+      let(:link_schema) { list }
+      it { is_expected.to be_falsey }
+    end
+  end
+
+  describe '#parameters' do
+    let(:parameters) { identify.parameters }
+
+    it 'returns an array of parameters' do
+      expect(parameters).to be_an(Array)
+    end
+
+    it 'returns the right number of parameters' do
+      expect(parameters.length).to eq(1)
+    end
+
+    it 'gives parameters the right names' do
+      expect(parameters.first.name)
+        .to eq('resource_uuid_field_or_resource_email_field')
+    end
+
+    it 'gives parameters the right descriptions' do
+      expect(parameters.first.description)
+        .to eq('A sample UUID field or A sample email address field')
+    end
+  end
+
+  describe '#construct_path' do
+    subject(:method) { -> { info.construct_path(*args) } }
+
+    context 'with valid args' do
+      let(:args) { ['4472831-bf66-4bc2-865f-e2c4c2b14c78'] }
+      it 'prepends a relative url to the action' do
+        expect(method.call).to eq('/resource/4472831-bf66-4bc2-865f-e2c4c2b14c78')
+      end
+    end
+
+    context 'with missing args' do
+      let(:args) { [] }
+      it { is_expected.to raise_error(ArgumentError) }
+    end
+
+    context 'with unwanted args' do
+      let(:args) { %w(too many args) }
+      it { is_expected.to raise_error(ArgumentError) }
+    end
+
+    it 'returns relative url' do
+      expect(update.construct_path('4472831-bf66-4bc2-865f-e2c4c2b14c78'))
+        .to eq('/resource/4472831-bf66-4bc2-865f-e2c4c2b14c78')
+    end
+  end
+end

data/spec/atum/core/schema/parameter_choice_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Atum::Core::Schema::ParameterChoice do
+  let(:param_1) { Atum::Core::Schema::Parameter.new('resource', 'id', 'foo') }
+  let(:param_2) { Atum::Core::Schema::Parameter.new('resource', 'email', 'bar') }
+  let(:param_3) { Atum::Core::Schema::Parameter.new(nil, 'token', 'baz') }
+
+  let(:parameter_choice) { described_class.new('resource', parameters) }
+
+  describe '#description' do
+    let(:parameters) { [param_1, param_2, param_3] }
+    subject { parameter_choice.description }
+
+    it { is_expected.to eq('foo or bar or baz') }
+  end
+
+  describe '#inspect' do
+    let(:parameters) { [param_1, param_2, param_3] }
+
+    it 'should include each of the parameters' do
+      expect(parameter_choice.inspect).to include(param_1.inspect)
+      expect(parameter_choice.inspect).to include(param_2.inspect)
+      expect(parameter_choice.inspect).to include(param_3.inspect)
+    end
+  end
+
+  describe '#name' do
+    subject { parameter_choice.name }
+
+    context 'when both parameters have a resource name' do
+      let(:parameters) { [param_1, param_2] }
+      it { is_expected.to eq('resource_id_or_resource_email') }
+    end
+
+    context "when a parameter doesn't have a resource name" do
+      let(:parameters) { [param_1, param_3] }
+      it { is_expected.to eq('resource_id_or_resource_token') }
+    end
+  end
+end

data/spec/atum/core/schema/parameter_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Atum::Core::Schema::Parameter do
+  let(:name) { 'id' }
+  let(:description) { 'The ID for the resource Yo!' }
+  let(:resource_name) { 'resource' }
+  subject(:parameter) { described_class.new(resource_name, name, description) }
+
+  describe '#name' do
+    subject { parameter.name }
+    it { is_expected.to eq("#{resource_name}_#{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 include("#{resource_name}_#{name}") }
+    it { is_expected.to include("#{description}") }
+  end
+end

data/spec/atum/core/schema/resource_schema_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Atum::Core::Schema::ResourceSchema do
+  let(:schema) { Atum::Core::Schema::ApiSchema.new(SAMPLE_SCHEMA) }
+  let(:resource) { schema.resource_schema_for('resource') }
+
+  describe '#link_schema_for' do
+    it 'gets a link schema' do
+      expect(resource.link_schema_for('list').name).to eq('list')
+    end
+
+    it 'raises with unknown link' do
+      expect { resource.link_schema_for('lolno') }
+        .to raise_error(Atum::Core::SchemaError)
+    end
+  end
+
+  describe '#link_schemas' do
+    it 'returns an array of link schemas' do
+      expect(resource.link_schemas.map(&:name))
+        .to eq(%w(list info identify_resource create update delete))
+    end
+  end
+end

data/spec/atum/generation/generator_link_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Atum::Generation::GeneratorLink do
+  let(:generator_link) { described_class.new(link_schema) }
+
+  describe '#name' do
+    let(:link_schema) { double(name: 'foo') }
+    it 'delegates to the link schema' do
+      expect(generator_link.name).to eq('foo')
+    end
+  end
+
+  describe '#description' do
+    let(:link_schema) { double(description: 'a really cool link') }
+    it 'delegates to the link schema' do
+      expect(generator_link.description).to eq('a really cool link')
+    end
+  end
+
+  describe '#parameters' do
+    let(:params) { [double] }
+    let(:link_schema) { instance_double('LinkSchema', parameters: params) }
+
+    it 'includes the link schema param details' do
+      params.each do |param|
+        expect(generator_link.parameters).to include(param)
+      end
+    end
+
+    it 'adds an optional parameter' do
+      expect(generator_link.parameters.last).to be_an(Atum::Generation::OptionsParameter)
+    end
+  end
+
+  describe '#parameter_names_with_defaults' do
+    let(:link_schema) { double }
+    before do
+      allow(generator_link).to receive(:parameters)
+        .and_return([double(name: 'first_param'),
+                     double(name: 'options', default: '{}')])
+    end
+
+    it 'should return the right function signature' do
+      expect(generator_link.parameter_names_with_defaults).to eq(
+        'first_param, options = {}')
+    end
+  end
+
+  describe '#parameter_names' do
+    let(:link_schema) { double }
+    before do
+      allow(generator_link).to receive(:parameters)
+        .and_return([double(name: 'first_param'),
+                     double(name: 'options', default: '{}')])
+    end
+
+    it 'should return the right signature' do
+      expect(generator_link.parameter_names).to eq(
+        'first_param, options')
+    end
+  end
+end