praxis 2.0.pre.8 → 2.0.pre.13

data/lib/praxis/tasks/routes.rb

@@ -11,7 +11,7 @@ namespace :praxis do
     ]
 
     rows = []
-    Praxis::Application.instance.resource_definitions.each do |resource_definition|
+    Praxis::Application.instance.endpoint_definitions.each do |resource_definition|
       resource_definition.actions.each do |name, action|
         method = begin
           m = resource_definition.controller.instance_method(name)

data/lib/praxis/types/media_type_common.rb

@@ -6,14 +6,6 @@ module Praxis
       extend ::ActiveSupport::Concern
 
       module ClassMethods
-        def describe(shallow = false, **opts)
-          hash = super
-          unless shallow
-            hash.merge!(identifier: @identifier.to_s, description: @description, display_name: self.display_name)
-          end
-          hash
-        end
-
         def as_json_schema(**args)
           the_type = @attribute && @attribute.type || member_type
           the_type.as_json_schema(args)
@@ -38,9 +30,7 @@ module Praxis
 
         # Get or set the identifier of this media type.
         #
-        # @deprecated this method is not deprecated, but its return type will change to MediaTypeIdentifier in Praxis 1.0
-        #
-        # @return [String] the string-representation of this type's identifier
+        # @return [MediaTypeIdentifier] the string-representation of this type's identifier
         def identifier(identifier=nil)
           return @identifier unless identifier
           @identifier = MediaTypeIdentifier.load(identifier)

data/lib/praxis/version.rb

@@ -1,3 +1,3 @@
 module Praxis
-  VERSION = '2.0.pre.8'
+  VERSION = '2.0.pre.13'
 end

data/praxis.gemspec

@@ -24,7 +24,6 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'mustermann', '>=1.1', '<=2'
   spec.add_dependency 'activesupport', '>= 3'
   spec.add_dependency 'mime', '~> 0'
-  spec.add_dependency 'praxis-blueprints', '>= 3.5'
   spec.add_dependency 'attributor', '>= 5.5'
   spec.add_dependency 'thor'
   spec.add_dependency 'terminal-table', '~> 1.4'

data/spec/functional_spec.rb

@@ -146,7 +146,7 @@ describe 'Functional specs' do
   context 'bulk_create multipart' do
 
     let(:instance) { Instance.example }
-    let(:instance_json) { JSON.pretty_generate(instance.render(view: :create)) }
+    let(:instance_json) { JSON.pretty_generate(instance.render(fields: {id: true, name: true})) }
 
     let(:form) do
       form_data = MIME::Multipart::FormData.new
@@ -174,7 +174,7 @@ describe 'Functional specs' do
 
       response_instance = JSON.parse(instance_part.body)
       expect(response_instance["key"]).to eq(instance.id)
-      expect(response_instance["value"].values).to eq(instance.render(view: :create).values)
+      expect(response_instance["value"].values).to eq(instance.render(fields: {id: true, name: true}).values)
     end
   end
 
@@ -205,12 +205,10 @@ describe 'Functional specs' do
       its(['destination_path']) { should eq '/etc/defaults' }
 
       context 'response["file"]' do
-        subject(:file) { response['file'] }
-
         its(['filename']) { should eq('docker') }
         its(['type']) { should eq('text/plain') }
         its(['name']) { should eq('file') }
-        its(['tempfile']) { should eq('DOCKER_HOST=tcp://127.0.0.1:2375') }
+        its(['contents']) { should eq('DOCKER_HOST=tcp://127.0.0.1:2375') }
       end
     end
 
@@ -231,7 +229,7 @@ describe 'Functional specs' do
         response = JSON.parse(last_response.body)
 
         expect(response['name']).to eq('ValidationError')
-        expect(response['errors']).to eq(["Attribute $.payload.key(\"destination_path\") is required"])
+        expect(response['errors']).to eq(["Attribute $.payload.destination_path is required"])
       end
 
     end
@@ -259,7 +257,7 @@ describe 'Functional specs' do
       before do
         post '/api/clouds/1/instances/2/files?api_version=1.0', body, 'CONTENT_TYPE' => content_type, 'global_session' => session
       end
-      its(:keys){ should eq(['destination_path','file','options'])}
+      its(:keys){ should eq(['destination_path','name','filename','type','contents','options'])}
       its(['options']){ should eq({"extra_thing"=>"I am extra"})}
     end
 
@@ -334,8 +332,6 @@ describe 'Functional specs' do
     let(:content_type){ 'application/json' }
     it 'can terminate instances with POST' do
       post '/api/clouds/23/instances/1/terminate?api_version=1.0', nil, 'CONTENT_TYPE' => content_type, 'global_session' => session
-      puts last_response.body
-      #binding.pry
       expect(last_response.status).to eq(200)
     end
     it 'can terminate instances with DELETE' do

data/spec/praxis/action_definition_spec.rb

@@ -8,14 +8,14 @@ describe Praxis::ActionDefinition do
       attribute :one, String
       attribute :two, Integer
     end
-    view :default do
+    default_fieldset do
       attribute :one
     end
   end
 
-  let(:resource_definition) do
+  let(:endpoint_definition) do
     Class.new do
-      include Praxis::ResourceDefinition
+      include Praxis::EndpointDefinition
 
       def self.name
         'FooBar'
@@ -43,7 +43,7 @@ describe Praxis::ActionDefinition do
         headers headers if headers
       end
     end
-    Praxis::ActionDefinition.new(:foo, resource_definition) do
+    Praxis::ActionDefinition.new(:foo, endpoint_definition) do
       routing { get '/:one' }
       payload { attribute :two, String }
       headers { header "X_REQUESTED_WITH", 'XMLHttpRequest' }
@@ -54,7 +54,7 @@ describe Praxis::ActionDefinition do
 
   context '#initialize' do
     its('name')                { should eq :foo }
-    its('resource_definition') { should be resource_definition }
+    its('endpoint_definition') { should be endpoint_definition }
     its('params.attributes')   { should have_key :one }
     its('params.attributes')   { should have_key :inherited }
     its('payload.attributes')  { should have_key :two }
@@ -78,17 +78,9 @@ describe Praxis::ActionDefinition do
     it { should include :created }
   end
 
-  describe '#allowed_responses' do
-    it 'has some tests after we stop using ApiDefinition.instance'
-  end
-
-  describe '#use' do
-    it 'has some tests after we stop using ApiDefinition.instance'
-  end
-
   describe 'when a trait is used' do
     subject(:action) do
-      Praxis::ActionDefinition.new(:bar, resource_definition) do
+      Praxis::ActionDefinition.new(:bar, endpoint_definition) do
         trait :test
         routing { get '/:one' }
         params  { attribute :one, String }
@@ -277,11 +269,11 @@ describe Praxis::ActionDefinition do
   end
 
   context 'href generation' do
-    let(:resource_definition) { ApiResources::Instances }
-    subject(:action) { resource_definition.actions[:show] }
+    let(:endpoint_definition) { ApiResources::Instances }
+    subject(:action) { endpoint_definition.actions[:show] }
 
     it 'works' do
-      expansion = action.route.path.expand(cloud_id:232, id: 2)
+      expansion = action.route.path.expand(cloud_id: '232', id: '2')
       expect(expansion).to eq "/api/clouds/232/instances/2"
     end
 
@@ -332,9 +324,9 @@ describe Praxis::ActionDefinition do
 
     context 'where the action overrides a base_param' do
 
-      let(:resource_definition) do
+      let(:endpoint_definition) do
         Class.new do
-          include Praxis::ResourceDefinition
+          include Praxis::EndpointDefinition
 
           def self.name
             'FooBar'
@@ -349,7 +341,7 @@ describe Praxis::ActionDefinition do
       end
 
       let(:action) do
-        Praxis::ActionDefinition.new(:foo, resource_definition) do
+        Praxis::ActionDefinition.new(:foo, endpoint_definition) do
           routing { get '' }
           params  { attribute :app_name, Integer }
         end

data/spec/praxis/blueprint_spec.rb

@@ -0,0 +1,373 @@
+# frozen_string_literal: true
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Praxis::Blueprint do
+  subject(:blueprint_class) { PersonBlueprint }
+
+  its(:family) { should eq('hash') }
+
+  context 'deterministic examples' do
+    it 'works' do
+      person_1 = PersonBlueprint.example('person 1')
+      person_2 = PersonBlueprint.example('person 1')
+
+      expect(person_1.name).to eq(person_2.name)
+      expect(person_1.address.name).to eq(person_2.address.name)
+    end
+  end
+
+  context 'implicit default_fieldset (when not defined in the blueprint)' do
+    subject(:default_fieldset) { AddressBlueprint.default_fieldset }
+
+    it { should_not be(nil) }
+    it 'contains all attributes' do
+      simple_attributes = [:id, :name, :street, :state]
+      expect(default_fieldset.keys).to match_array(simple_attributes)
+      # Should not have blueprint-derived attributes (or collections of them)
+      expect(default_fieldset.keys).to_not include( AddressBlueprint.attributes.keys - simple_attributes )
+    end
+  end
+
+  context 'creating a new Blueprint class' do
+    subject!(:blueprint_class) do
+      Class.new(Praxis::Blueprint) do
+        domain_model Hash
+        attributes do
+          attribute :id, Integer
+        end
+      end
+    end
+
+    its(:finalized?) { should be(false) }
+    its(:domain_model) { should be(Hash) }
+
+    context '.finalize on Praxis::Blueprint' do
+      before do
+        expect(blueprint_class).to receive(:_finalize!).and_call_original
+        Praxis::Blueprint.finalize!
+      end
+
+      its(:finalized?) { should be(true) }
+    end
+
+    context '.finalize on that subclass' do
+      before do
+        expect(blueprint_class).to receive(:_finalize!).and_call_original
+        blueprint_class.finalize!
+      end
+
+      its(:finalized?) { should be(true) }
+    end
+  end
+
+  context 'creating a base abstract Blueprint class without attributes' do
+    subject!(:blueprint_class) do
+      Class.new(Praxis::Blueprint)
+    end
+
+    it 'skips attribute definition' do
+      expect(blueprint_class).to receive(:_finalize!).and_call_original
+      expect(blueprint_class).to_not receive(:define_attribute)
+      blueprint_class.finalize!
+      expect(blueprint_class.finalized?).to be(true)
+    end
+  end
+
+  it 'has an inner Struct class for the attributes' do
+    expect(blueprint_class.attribute.type).to be blueprint_class::Struct
+  end
+
+
+  context 'an instance' do
+    shared_examples 'a blueprint instance' do
+      let(:expected_name) { blueprint_instance.name }
+
+      context '#render' do
+        subject(:output) { blueprint_instance.render }
+
+        it { should have_key(:name) }
+        it 'has the right values' do
+          expect(subject[:name]).to eq(expected_name)
+        end
+      end
+
+      context 'validation' do
+        subject(:errors) { blueprint_class.validate(blueprint_instance) }
+        it { should be_empty }
+      end
+    end
+
+    context 'from Blueprint.example' do
+      subject(:blueprint_instance) do
+        blueprint_class.example('ExamplePersonBlueprint', 
+          address: nil,
+          prior_addresses: [],
+          work_address: nil,
+          myself: nil,
+          friends: []
+        )
+      end
+      it_behaves_like 'a blueprint instance'
+    end
+
+    context 'wrapping an object' do
+      let(:data) do
+        {
+          name: 'Bob',
+          full_name: FullName.example,
+          address: nil,
+          email: 'bob@example.com',
+          aliases: [],
+          prior_addresses: [],
+          parents: { father: Randgen.first_name, mother: Randgen.first_name },
+          href: 'www.example.com',
+          alive: true
+        }
+      end
+
+      let(:resource) { blueprint_class.load(data).object }
+
+      subject(:blueprint_instance) { blueprint_class.new(resource) }
+
+      it_behaves_like 'a blueprint instance'
+
+      context 'creating additional blueprint instances from that object' do
+        subject(:additional_instance) { blueprint_class.new(resource) }
+
+        context 'with caching enabled' do
+          around do |example|
+            Praxis::Blueprint.caching_enabled = true
+            Praxis::Blueprint.cache = Hash.new { |h, k| h[k] = {} }
+            example.run
+
+            Praxis::Blueprint.caching_enabled = false
+            Praxis::Blueprint.cache = nil
+          end
+
+          it 'uses the cache to memoize instance creation' do
+            expect(additional_instance).to be(additional_instance)
+            expect(blueprint_class.cache).to have_key(resource)
+            expect(blueprint_class.cache[resource]).to be(blueprint_instance)
+          end
+        end
+
+        context 'with caching disabled' do
+          it { should_not be blueprint_instance }
+        end
+      end
+    end
+  end
+
+  context '.validate' do
+    let(:hash) { { name: 'bob' } }
+    let(:person) { PersonBlueprint.load(hash) }
+    subject(:errors) { person.validate }
+
+    context 'that is valid' do
+      it { should be_empty }
+    end
+
+    context 'with invalid sub-attribute' do
+      let(:hash) { { name: 'bob', address: { state: 'ME' } } }
+
+      it { should have(1).item }
+      its(:first) { should =~ /Attribute \$.address.state/ }
+    end
+
+    context 'for objects of the wrong type' do
+      it 'raises an error' do
+        expect do
+          PersonBlueprint.validate(Object.new)
+        end.to raise_error(ArgumentError, /Error validating .* as PersonBlueprint for an object of type Object/)
+      end
+    end
+  end
+
+  context '.load' do
+    let(:hash) do
+      {
+        name: 'Bob',
+        full_name: { first: 'Robert', last: 'Robertson' },
+        address: { street: 'main', state: 'OR' }
+      }
+    end
+    subject(:person) { PersonBlueprint.load(hash) }
+
+    it { should be_kind_of(PersonBlueprint) }
+
+    context 'recursively loading sub-attributes' do
+      context 'for a Blueprint' do
+        subject(:address) { person.address }
+        it { should be_kind_of(AddressBlueprint) }
+      end
+      context 'for an Attributor::Model' do
+        subject(:full_name) { person.full_name }
+        it { should be_kind_of(FullName) }
+      end
+    end
+  end
+
+  context 'with a provided :reference option on attributes' do
+    context 'that does not match the value set on the class' do
+      subject(:mismatched_reference) do
+        Class.new(Praxis::Blueprint) do
+          self.reference = Class.new(Praxis::Blueprint)
+          attributes(reference: Class.new(Praxis::Blueprint)) {}
+        end
+      end
+
+      it 'should raise an error' do
+        expect do
+          mismatched_reference.attributes
+        end.to raise_error(/Reference mismatch/)
+      end
+    end
+  end
+
+  context '.example' do
+    context 'with some attribute values provided' do
+      let(:name) { 'Sir Bobbert' }
+      subject(:person) { PersonBlueprint.example(name: name) }
+      its(:name) { should eq(name) }
+    end
+  end
+
+  context '.render' do
+    let(:person) { PersonBlueprint.example('1') }
+    it 'is an alias to dump' do
+      person.object.contents
+      rendered = PersonBlueprint.render(person, fields: [:name, :full_name])
+      dumped = PersonBlueprint.dump(person, fields: [:name, :full_name])
+      expect(rendered).to eq(dumped)
+    end
+  end
+
+  context '#render' do
+    let(:person) { PersonBlueprint.example }
+    let(:fields) do 
+      {
+        name: true,
+        full_name: true,
+        address: {
+          street: true,
+          state: true,
+        },
+        prior_addresses: {
+          street: true,
+          state: true,
+        }
+      }
+    end
+    let(:render_opts) { {} }
+    subject(:output) { person.render(fields: fields, **render_opts) }
+
+    context 'without passing fields' do
+      it 'renders the default field set defined' do 
+        rendered = person.render( **render_opts)
+        default_top_fields = PersonBlueprint.default_fieldset.keys
+        expect(rendered.keys).to match_array(default_top_fields)
+        expect(default_top_fields).to match_array([
+          :name,
+          :full_name,
+          :address,
+          :prior_addresses])
+      end
+    end
+    context 'with a sub-attribute that is a blueprint' do
+      it { should have_key(:name) }
+      it { should have_key(:address) }
+      it 'renders the sub-attribute correctly' do
+        expect(output[:address]).to have_key(:street)
+        expect(output[:address]).to have_key(:state)
+      end
+
+      it 'reports a dump error with the appropriate context' do
+        expect(person.address).to receive(:state).and_raise('Kaboom')
+        expect do
+          person.render(fields: fields, context: ['special_root'])
+        end.to raise_error(/Error while dumping attribute state of type AddressBlueprint for context special_root.address. Reason: .*Kaboom/)
+      end
+    end
+
+    context 'with sub-attribute that is an Attributor::Model' do
+      it { should have_key(:full_name) }
+      it 'renders the model correctly' do
+        expect(output[:full_name]).to be_kind_of(Hash)
+        expect(output[:full_name]).to have_key(:first)
+        expect(output[:full_name]).to have_key(:last)
+      end
+    end
+
+    context 'using the `fields` option' do
+      context 'as a hash' do
+        subject(:output) { person.render(fields: { address: { state: true } }) }
+        it 'should only have the address rendered' do
+          expect(output.keys).to eq [:address]
+        end
+        it 'address should only have state' do
+          expect(output[:address].keys).to eq [:state]
+        end
+      end
+      context 'as a simple array' do
+        subject(:output) { person.render(fields: [:full_name]) }
+        it 'accepts it as the list of top-level attributes to be rendered' do
+          expect(output.keys).to match_array([:full_name])
+        end
+      end
+    end
+
+    context 'using un-expanded fields for blueprints' do
+      let(:fields) do 
+        {
+          name: true,
+          address: true, # A blueprint!
+        }
+      end
+      it 'should still render the blueprint sub-attribute with its default fieldset' do
+        address_default_top_fieldset = AddressBlueprint.default_fieldset.keys
+        expect(output[:address].keys).to match(address_default_top_fieldset)
+      end
+
+    end
+  end
+
+  context '.as_json_schema' do
+    it 'delegates to the attribute type' do
+      expect(PersonBlueprint.attribute.type).to receive(:as_json_schema)
+      PersonBlueprint.as_json_schema
+    end
+  end
+  context '.json_schema_type' do
+    it 'delegates to the attribute type' do
+      expect(PersonBlueprint.attribute.type).to receive(:json_schema_type)
+      PersonBlueprint.json_schema_type
+    end
+  end
+
+  context 'FieldsetParser' do
+    let(:definition_block) do
+      Proc.new do
+        attribute :one
+        attribute :two do
+          attribute :sub_two
+        end
+      end
+    end
+    subject { described_class::FieldsetParser.new(&definition_block) }
+
+    it 'parses properly' do
+      expect(subject.fieldset).to eq(one: true, two: { sub_two: true} )
+    end
+
+    context 'with attribute parameters' do
+      let(:definition_block) do
+        Proc.new do
+          attribute :one, view: :other
+        end
+      end
+      it 'complains and gives instructions if legacy view :default' do
+        expect{ subject.fieldset }.to raise_error(/Default fieldset definitions do not accept parameters/)
+      end
+    end
+  end
+end