encore 0.0.3 → 0.1

data/spec/encore/serializer/links_resource_spec.rb

@@ -0,0 +1,294 @@
+require 'spec_helper'
+
+describe Encore::Serializer do
+  let(:serializer) { Encore::Serializer::Instance }
+  let(:objects) { User.all }
+  let(:serialized) { serializer.new(objects, include: include).as_json }
+
+  let(:run_migrations!) do
+    run_migration do
+      create_table(:users, force: true) do |t|
+        t.string :name, default: nil
+        t.integer :project_id
+      end
+      create_table(:projects, force: true) do |t|
+        t.string :name, default: nil
+        t.integer :user_id
+      end
+    end
+  end
+
+  before do
+    run_migrations!
+    spawn_objects!
+    create_records!
+  end
+
+  context 'can access' do
+    context 'default' do
+      let(:spawn_objects!) do
+        spawn_model('User') do
+          belongs_to :project
+          belongs_to :irrelevant_reflection
+        end
+        spawn_serializer('UserSerializer') do
+          attributes :name, :links
+
+          def can_include
+            %i(project)
+          end
+        end
+        spawn_model('Project') do
+          has_many :users
+        end
+        spawn_serializer('ProjectSerializer') do
+          attributes :name
+        end
+
+      end
+      let(:create_records!) do
+        User.create name: 'Allan', project_id: 1
+        User.create name: 'Doe', project_id: 2
+      end
+      let(:include) { '' }
+
+      it { expect(serialized[:users][0][:links][:irrelevant_reflection]).to eq(nil) }
+    end
+
+    context 'not loaded with access' do
+      let(:spawn_objects!) do
+        spawn_model('User') do
+          belongs_to :project
+          belongs_to :irrelevant_reflection
+        end
+        spawn_serializer('UserSerializer') do
+          attributes :name, :links
+
+          def can_include
+            %i(project)
+          end
+        end
+        spawn_model('Project') do
+          has_many :users
+        end
+        spawn_serializer('ProjectSerializer') do
+          attributes :name
+        end
+
+      end
+      let(:create_records!) do
+        User.create name: 'Allan', project_id: 1
+        User.create name: 'Doe', project_id: 2
+      end
+      let(:include) { '' }
+
+      it { expect(serialized[:users][0][:links][:project].present?).to eq(true) }
+    end
+
+    context 'not loaded without access' do
+      let(:spawn_objects!) do
+        spawn_model('User') do
+          belongs_to :project
+          belongs_to :irrelevant_reflection
+        end
+        spawn_serializer('UserSerializer') do
+          attributes :name, :links
+
+          def can_include
+            %i(project)
+          end
+
+          def can_access
+            []
+          end
+        end
+        spawn_model('Project') do
+          has_many :users
+        end
+        spawn_serializer('ProjectSerializer') do
+          attributes :name
+        end
+
+      end
+      let(:create_records!) do
+        User.create name: 'Allan', project_id: 1
+        User.create name: 'Doe', project_id: 2
+      end
+      let(:include) { '' }
+
+      it { expect(serialized[:users][0][:links][:project].present?).to eq(false) }
+    end
+
+    context 'loaded without access' do
+      let(:spawn_objects!) do
+        spawn_model('User') do
+          belongs_to :project
+          belongs_to :irrelevant_reflection
+        end
+        spawn_serializer('UserSerializer') do
+          attributes :name, :links
+
+          def can_include
+            %i(project)
+          end
+
+          def can_access
+            []
+          end
+        end
+        spawn_model('Project') do
+          has_many :users
+        end
+        spawn_serializer('ProjectSerializer') do
+          attributes :name
+        end
+
+      end
+      let(:create_records!) do
+        User.create name: 'Allan', project_id: 1
+        User.create name: 'Doe', project_id: 2
+      end
+      let(:include) { 'project' }
+
+      it { expect(serialized[:users][0][:links][:project].present?).to eq(true) }
+    end
+  end
+
+  context 'belongs_to' do
+    let(:spawn_objects!) do
+      spawn_model('User') do
+        belongs_to :project
+      end
+      spawn_serializer('UserSerializer') do
+        attributes :name, :links
+
+        def can_include
+          %i(project)
+        end
+      end
+      spawn_model('Project') do
+        has_many :users
+      end
+      spawn_serializer('ProjectSerializer') do
+        attributes :name
+      end
+
+    end
+    let(:create_records!) do
+      User.create name: 'Allan', project_id: 1
+      User.create name: 'Doe', project_id: 2
+    end
+
+    context 'not included' do
+      let(:include) { '' }
+      let(:expected_project) do
+        {
+          href: '/projects/1',
+          id: '1',
+          type: 'projects'
+        }
+      end
+
+      it { expect(serialized[:users][0][:links][:project]).to eq(expected_project) }
+    end
+
+    context 'included' do
+      let(:include) { 'project' }
+      let(:expected_project) { '1' }
+
+      it { expect(serialized[:users][0][:links][:project]).to eq(expected_project) }
+    end
+  end
+
+  context 'has_many' do
+    let(:spawn_objects!) do
+      spawn_model('User') do
+        has_many :projects
+      end
+      spawn_serializer('UserSerializer') do
+        attributes :name, :links
+
+        def can_include
+          %i(projects)
+        end
+      end
+      spawn_model('Project') do
+        belongs_to :user
+      end
+      spawn_serializer('ProjectSerializer') do
+        attributes :name
+      end
+    end
+
+    let(:create_records!) do
+      User.create name: 'Allan'
+      User.create name: 'Doe'
+      Project.create name: 'p1', user_id: 1
+      Project.create name: 'p2', user_id: 1
+    end
+
+    context 'not included' do
+      let(:include) { '' }
+      let(:expected_project) do
+        {
+          href: '/projects?user_id=1',
+          type: 'projects'
+        }
+      end
+
+      it { expect(serialized[:users][0][:links][:projects]).to eq(expected_project) }
+    end
+
+    context 'included' do
+      let(:include) { 'projects' }
+      let(:expected_project) { %w(1 2) }
+
+      it { expect(serialized[:users][0][:links][:projects]).to eq(expected_project) }
+    end
+  end
+
+  context 'has_one' do
+    let(:spawn_objects!) do
+      spawn_model('User') do
+        has_one :project
+      end
+      spawn_serializer('UserSerializer') do
+        attributes :name, :links
+
+        def can_include
+          %i(project)
+        end
+      end
+      spawn_model('Project')
+      spawn_serializer('ProjectSerializer') do
+        attributes :name
+      end
+    end
+
+    let(:create_records!) do
+      User.create name: 'Allan'
+      User.create name: 'Doe'
+      Project.create name: 'p1', user_id: 1
+      Project.create name: 'p2', user_id: 2
+    end
+
+    context 'not included' do
+      let(:include) { '' }
+      let(:expected_project) do
+        {
+          href: '/users/1/project',
+          type: 'projects'
+        }
+      end
+
+      it { expect(serialized[:users][0][:links][:project]).to eq(expected_project) }
+    end
+
+    context 'included' do
+      let(:include) { 'project' }
+      let(:expected_project) { '1' }
+
+      it { expect(serialized[:users][0][:links][:project]).to eq(expected_project) }
+    end
+  end
+end

data/spec/encore/serializer/main_meta_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Encore::Serializer do
+  let(:serializer) { Encore::Serializer::Instance }
+  let(:objects) { User.all }
+  let(:serialized) { serializer.new(objects, page: page).as_json }
+
+  let(:run_migrations!) do
+    run_migration do
+      create_table(:users, force: true) do |t|
+        t.string :name, default: nil
+        t.string :discarded_attribute, default: nil
+      end
+    end
+  end
+
+  let(:spawn_objects!) do
+    spawn_model('User')
+    spawn_serializer('UserSerializer') do
+      attributes :name
+    end
+  end
+
+  let(:create_records!) do
+    User.create name: 'Allan'
+    User.create name: 'Doe'
+    User.create name: 'Ding'
+    User.create name: 'Bob'
+  end
+
+  let(:paging_config) do
+    double(
+      'Kaminari',
+      page_method_name: 'page',
+      default_per_page: 1,
+      max_per_page: 1,
+      max_pages: 10
+    )
+  end
+
+  before do
+    expect(Kaminari).to receive(:config).and_return(paging_config).at_least(:once)
+    run_migrations!
+    spawn_objects!
+    create_records!
+  end
+
+  context 'page 1' do
+    let(:page) { 1 }
+
+    it { expect(serialized[:meta][:users][:page]).to eq(1) }
+    it { expect(serialized[:meta][:users][:count]).to eq(4) }
+    it { expect(serialized[:meta][:users][:page_count]).to eq(4) }
+    it { expect(serialized[:meta][:users][:next_page]).to eq(2) }
+  end
+
+  context 'page 2' do
+    let(:page) { 2 }
+
+    it { expect(serialized[:meta][:users][:page]).to eq(2) }
+    it { expect(serialized[:meta][:users][:count]).to eq(4) }
+    it { expect(serialized[:meta][:users][:page_count]).to eq(4) }
+    it { expect(serialized[:meta][:users][:previous_page]).to eq(1) }
+    it { expect(serialized[:meta][:users][:next_page]).to eq(3) }
+  end
+end

data/spec/encore/serializer/main_resource_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Encore::Serializer do
+  let(:serializer) { Encore::Serializer::Instance }
+  let(:objects) { User.all }
+  let(:serialized) { serializer.new(objects).as_json }
+
+  let(:run_migrations!) do
+    run_migration do
+      create_table(:users, force: true) do |t|
+        t.string :name, default: nil
+        t.string :discarded_attribute, default: nil
+      end
+    end
+  end
+
+  let(:spawn_objects!) do
+    spawn_model('User')
+    spawn_serializer('UserSerializer') do
+      attributes :name
+    end
+  end
+
+  let(:create_records!) do
+    User.create name: 'Allan', discarded_attribute: 'THIS IS MY PASSWORD'
+    User.create name: 'Doe'
+  end
+
+  before do
+    run_migrations!
+    spawn_objects!
+    create_records!
+  end
+
+  it { expect(serialized[:users].count).to eq(2) }
+  it { expect(serialized[:users]).to eq([{ name: 'Allan' }, { name: 'Doe' }]) }
+end

data/spec/encore/serializer/no_paging_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Encore::Serializer do
+  let(:serializer) { Encore::Serializer::Instance }
+  let(:objects) { User.all }
+  let(:serialized) { serializer.new(objects, skip_paging: true).as_json }
+
+  let(:run_migrations!) do
+    run_migration do
+      create_table(:users, force: true) do |t|
+        t.string :name, default: nil
+        t.string :discarded_attribute, default: nil
+      end
+    end
+  end
+
+  let(:spawn_objects!) do
+    spawn_model('User')
+    spawn_serializer('UserSerializer') do
+      attributes :name
+    end
+  end
+
+  let(:create_records!) do
+    User.create name: 'Allan'
+    User.create name: 'Doe'
+    User.create name: 'Ding'
+    User.create name: 'Bob'
+  end
+
+  before do
+    expect(User).to receive(:page).never
+    run_migrations!
+    spawn_objects!
+    create_records!
+  end
+
+  it { expect(serialized[:meta]).to eq({}) }
+  it { expect(serialized[:users].count).to eq(4) }
+end

data/spec/encore_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Encore do
+end

data/spec/spec_helper.rb

@@ -1,38 +1,25 @@
-$:.unshift File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
 
-# Test dependencies
 require 'rspec'
 require 'sqlite3'
 
-# Data structure
-require 'active_record'
-require 'ostruct'
-
-# Encore
 require 'encore'
 
 # Require our macros and extensions
-Dir[File.expand_path('../../spec/support/macros/*.rb', __FILE__)].map(&method(:require))
-
-# Emulate our railtie's behavior
-require 'encore/railtie'
-Encore::Helpers::ControllerHelper.inject_into_action_controller
+Dir[File.expand_path('../../spec/support/macros/**/*.rb', __FILE__)].map(&method(:require))
 
 RSpec.configure do |config|
   # Include our macros
   config.include DatabaseMacros
   config.include ModelMacros
 
-  # Shared examples aliases
-  config.alias_it_should_behave_like_to :it_has_behavior, 'has behavior:'
-
-  config.before(:each) do
-    # Create the SQLite database
-    setup_database
+  config.before :each do
+    # Setup the database
+    setup_database(adapter: 'sqlite3', database: 'encore_test')
   end
 
-  config.after(:each) do
-    # Make sure we remove our test database file
-    cleanup_database
+  config.before :suite do
+    # Enforce available locales (otherwise generating error messages throws a warning)
+    I18n.enforce_available_locales = true
   end
 end

data/spec/support/macros/database/database_adapter.rb

@@ -0,0 +1,9 @@
+class DatabaseAdapter
+  def initialize(opts = {})
+    @database = opts[:database]
+  end
+
+  def establish_connection!
+    ActiveRecord::Base.establish_connection(database_configuration)
+  end
+end

data/spec/support/macros/database/sqlite3_adapter.rb

@@ -0,0 +1,14 @@
+require_relative 'database_adapter'
+
+class Sqlite3Adapter < DatabaseAdapter
+  def database_configuration
+    {
+      adapter: 'sqlite3',
+      database: ':memory:'
+    }
+  end
+
+  def reset_database!
+    ActiveRecord::Base.connection.execute("select 'drop table ' || name || ';' from sqlite_master where type = 'table';")
+  end
+end

data/spec/support/macros/database_macros.rb

@@ -5,29 +5,18 @@ module DatabaseMacros
     klass = Class.new(ActiveRecord::Migration)
 
     # Create a new `up` that executes the argument
-    klass.send(:define_method, :up) { self.instance_exec(&block) }
+    klass.send(:define_method, :up) { instance_exec(&block) }
 
     # Create a new instance of it and execute its `up` method
     klass.new.up
   end
 
-  def self.database_file
-    @database_file || File.expand_path('../test.db', __FILE__)
-  end
-
-  def setup_database
-    # Make sure the test database file is gone
-    cleanup_database
-
-    # Establish the connection
-    SQLite3::Database.new FileUtils.touch(DatabaseMacros.database_file).first
-    ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: DatabaseMacros.database_file)
+  def setup_database(opts = {})
+    adapter = "#{opts[:adapter].capitalize}Adapter".constantize.new(database: opts[:database])
+    adapter.establish_connection!
+    adapter.reset_database!
 
     # Silence everything
     ActiveRecord::Base.logger = ActiveRecord::Migration.verbose = false
   end
-
-  def cleanup_database
-    FileUtils.rm(DatabaseMacros.database_file) if File.exists?(DatabaseMacros.database_file)
-  end
 end

data/spec/support/macros/model_macros.rb

@@ -1,37 +1,22 @@
 module ModelMacros
-  # Create a new Encore entity
-  def spawn_entity(klass_name, &block)
-    spawn_klass klass_name, Object do
-      include Encore::Entity
-      instance_exec(&block) if block
-    end
-  end
-
   # Create a new ActiveRecord model
   def spawn_model(klass_name, &block)
-    spawn_klass klass_name, ActiveRecord::Base  do
-      instance_exec(&block) if block
-    end
-  end
-
-  # Create a new OpenStruct struct
-  def spawn_struct(klass_name, &block)
-    spawn_klass klass_name, OpenStruct do
+    spawn_object klass_name, ActiveRecord::Base do
       instance_exec(&block) if block
     end
   end
 
-  # Create a new ActionPack controller
-  def spawn_controller(klass_name, &block)
-    spawn_klass klass_name, ActionController::Base do
+  # Create a new Encore::Serializer object
+  def spawn_serializer(klass_name, &block)
+    spawn_object klass_name, Encore::Serializer::Base do
       instance_exec(&block) if block
     end
   end
 
-  protected
+protected
 
-  # Create a new class
-  def spawn_klass(klass_name, parent_klass, &block)
+  # Create a new model class
+  def spawn_object(klass_name, parent_klass, &block)
     Object.instance_eval { remove_const klass_name } if Object.const_defined?(klass_name)
     Object.const_set(klass_name, Class.new(parent_klass))
     Object.const_get(klass_name).class_eval(&block) if block_given?