backframe 0.0.49 → 1.0.0

data/lib/backframe/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Backframe
-  VERSION = '0.0.49'
+  VERSION = '1.0.0'
 end

data/spec/fixtures/active_record.rb

@@ -0,0 +1,22 @@
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+
+ActiveRecord::Schema.define do
+
+  self.verbose = false
+
+  create_table :contacts, force: true do |t|
+    t.string :first_name
+    t.string :last_name
+    t.string :email
+    t.references :photo
+    t.timestamps null: false
+  end
+
+  create_table :photos, force: true do |t|
+    t.string :path
+    t.timestamps null: false
+  end
+
+end

data/spec/fixtures/models.rb

@@ -0,0 +1,25 @@
+require 'active_record'
+
+module Backframe
+
+  module Fixtures
+
+    class Contact < ActiveRecord::Base
+
+      belongs_to :photo
+
+      validates :first_name, presence: true
+      validates :last_name, presence: true
+      validates :email, presence: true
+
+    end
+
+    class Photo < ActiveRecord::Base
+
+      has_one :contact
+
+    end
+
+  end
+
+end

data/spec/fixtures/queries.rb

@@ -0,0 +1,28 @@
+require 'backframe'
+
+module Backframe
+
+  module Fixtures
+
+    class ContactQuery < Backframe::Query
+
+      def filter(records, filters)
+        records = records.where(first_name: filters[:first_name]) if filters.key?(:first_name)
+        records = records.where(last_name: filters[:last_name]) if filters.key?(:last_name)
+        records = records.where(email: filters[:email]) if filters.key?(:email)
+        records
+      end
+
+    end
+
+    class PhotoQuery < Backframe::Query
+
+      def filter(records, filters)
+        records
+      end
+
+    end
+
+  end
+
+end

data/spec/fixtures/seeds.rb

@@ -0,0 +1,12 @@
+require 'active_record'
+
+
+greg_photo = Backframe::Fixtures::Photo.create(path: '/images/greg.jpg')
+megan_photo = Backframe::Fixtures::Photo.create(path: '/images/megan.jpg')
+kath_photo = Backframe::Fixtures::Photo.create(path: '/images/kath.jpg')
+armand_photo = Backframe::Fixtures::Photo.create(path: '/images/armand.jpg')
+
+greg = Backframe::Fixtures::Contact.create(first_name: 'Greg', last_name: 'Kops', email: 'greg@thinktopography.com', photo: greg_photo)
+megan = Backframe::Fixtures::Contact.create(first_name: 'Megan', last_name: 'Pugh', email: 'megan@thinktopography.com', photo: megan_photo)
+kath = Backframe::Fixtures::Contact.create(first_name: 'Kath', last_name: 'Tibbetts', email: 'kath@thinktopography.com', photo: kath_photo)
+armand = Backframe::Fixtures::Contact.create(first_name: 'Armand', last_name: 'Zerilli', email: 'armand@thinktopography.com', photo: armand_photo)

data/spec/fixtures/serializers.rb

@@ -0,0 +1,23 @@
+require 'active_model_serializers'
+
+module Backframe
+
+  module Fixtures
+
+    class ContactSerializer < ActiveModel::Serializer
+
+      attributes :id, :first_name, :last_name, :email
+
+      belongs_to :photo
+
+    end
+
+    class PhotoSerializer < ActiveModel::Serializer
+
+      attributes :id, :path
+
+    end
+
+  end
+
+end

data/spec/fixtures/services.rb

@@ -0,0 +1,26 @@
+require 'backframe'
+
+module Backframe
+
+  module Fixtures
+
+    class CreateContactService < Backframe::Service
+
+      def initialize(params)
+        @params = params
+      end
+
+      def perform
+        create_contact
+        { contact: @contact }
+      end
+
+      def create_contact
+        @contact = Contact.create!(@params)
+      end
+
+    end
+
+  end
+
+end

data/spec/query/sort_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Backframe::Query::Sort do
+
+  it 'returns the default sort order' do
+    actual = Backframe::Query::Sort.parse()
+    expected = [
+      { key: 'created_at', order: 'DESC' },
+    ]
+    expect(actual).to eq(expected)
+  end
+
+  it 'returns a simple asecnding sort order' do
+    actual = Backframe::Query::Sort.parse('first_name')
+    expected = [
+      { key: 'first_name', order: 'ASC' },
+    ]
+    expect(actual).to eq(expected)
+  end
+
+  it 'returns a simple desecnding sort order' do
+    actual = Backframe::Query::Sort.parse('-first_name')
+    expected = [
+      { key: 'first_name', order: 'DESC' },
+    ]
+    expect(actual).to eq(expected)
+  end
+
+  it 'returns a complex mixed sort order' do
+    actual = Backframe::Query::Sort.parse('first_name,-last_name')
+    expected = [
+      { key: 'first_name', order: 'ASC' },
+      { key: 'last_name', order: 'DESC' }
+    ]
+    expect(actual).to eq(expected)
+  end
+
+  it 'doesnt care about spaces' do
+    actual = Backframe::Query::Sort.parse(' first_name , last_name ')
+    expected = [
+      { key: 'first_name', order: 'ASC' },
+      { key: 'last_name', order: 'ASC' }
+    ]
+    expect(actual).to eq(expected)
+  end
+
+end

data/spec/query_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Backframe::Query do
+
+  before(:all) do
+    @contact = Backframe::Fixtures::Contact
+    @greg = @contact.find(1)
+    @megan = @contact.find(2)
+    @kath = @contact.find(3)
+    @armand = @contact.find(4)
+  end
+
+  it 'return no filtering as the default' do
+    records = Backframe::Query.perform(@contact, {})
+    expect(records).to eq(@contact)
+  end
+
+  it 'can filter' do
+    records = Backframe::Fixtures::ContactQuery.perform(@contact, { first_name: 'Greg' })
+    expect(records.count).to eq(1)
+    expect(records.first.id).to eq(@greg.id)
+  end
+
+  it 'can sort on a single field ascending' do
+    records = Backframe::Fixtures::ContactQuery.perform(@contact, { sort: 'created_at' })
+    expect(records.first.id).to eq(@greg.id)
+  end
+
+  it 'can sort on a single field descending' do
+    records = Backframe::Fixtures::ContactQuery.perform(@contact, { sort: '-created_at' })
+    expect(records.first.id).to eq(@armand.id)
+  end
+
+  # it 'can sort on multiple fields with mixed order' do
+  #   post = Backframe::Fixtures::Post
+  #   records = Backframe::Fixtures::PostQuery.perform(post, { sort: '-last_name,created_at' })
+  #   expect(records[0].id).to eq(@post3.id)
+  #   expect(records[1].id).to eq(@post1.id)
+  #   expect(records[2].id).to eq(@post2.id)
+  # end
+
+  it 'ignore invalid sort' do
+    records = Backframe::Fixtures::ContactQuery.perform(@contact, { sort: '123^' })
+    ids = records.all.map { |r| r.id }
+    expect(ids).to eq([1,2,3,4])
+  end
+
+  it 'can exclude_ids' do
+    records = Backframe::Fixtures::ContactQuery.perform(@contact, { exclude_ids: '1,2' })
+    ids = records.all.map { |r| r.id }
+    expect(ids).not_to include(1)
+    expect(ids).not_to include(2)
+    expect(ids).to include(3)
+    expect(ids).to include(4)
+  end
+
+  it 'ignore invalid exclude_ids' do
+    records = Backframe::Fixtures::ContactQuery.perform(@contact, { exclude_ids: '1,b,c' })
+    ids = records.all.map { |r| r.id }
+    expect(ids).to eq([1,2,3,4])
+  end
+
+end

data/spec/response/adapter/csv_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Backframe::Response::Adapter::Csv do
+
+  it 'renders full payload' do
+    collection = Backframe::Response::Collection.new(Backframe::Fixtures::Contact, nil, nil)
+    fields = Backframe::Response::Fields.new(Backframe::Fixtures::Contact, nil)
+    actual = Backframe::Response::Adapter::Csv.render(collection, fields)
+    expected = [
+      'id,first_name,last_name,email,photo.id,photo.path',
+      '1,Greg,Kops,greg@thinktopography.com,1,/images/greg.jpg',
+      '2,Megan,Pugh,megan@thinktopography.com,2,/images/megan.jpg',
+      '3,Kath,Tibbetts,kath@thinktopography.com,3,/images/kath.jpg',
+      '4,Armand,Zerilli,armand@thinktopography.com,4,/images/armand.jpg'
+    ].join("\n")
+    expect(actual).to eq(expected)
+  end
+
+  it 'renders with a single simple key' do
+    collection = Backframe::Response::Collection.new(Backframe::Fixtures::Contact, nil, nil)
+    fields = Backframe::Response::Fields.new(Backframe::Fixtures::Contact, 'first_name')
+    actual = Backframe::Response::Adapter::Csv.render(collection, fields)
+    expected = ['first_name','Greg','Megan','Kath','Armand'].join("\n")
+    expect(actual).to eq(expected)
+  end
+
+  it 'renders with a single nested key' do
+    collection = Backframe::Response::Collection.new(Backframe::Fixtures::Contact, nil, nil)
+    fields = Backframe::Response::Fields.new(Backframe::Fixtures::Contact, 'photo.id')
+    actual = Backframe::Response::Adapter::Csv.render(collection, fields)
+    expected = ['photo.id','1','2','3','4'].join("\n")
+    expect(actual).to eq(expected)
+  end
+
+  it 'renders with pagination' do
+    collection = Backframe::Response::Collection.new(Backframe::Fixtures::Contact, 1, 2)
+    fields = Backframe::Response::Fields.new(Backframe::Fixtures::Contact, nil)
+    actual = Backframe::Response::Adapter::Csv.render(collection, fields)
+    expected = [
+      'id,first_name,last_name,email,photo.id,photo.path',
+      '1,Greg,Kops,greg@thinktopography.com,1,/images/greg.jpg',
+      '2,Megan,Pugh,megan@thinktopography.com,2,/images/megan.jpg'
+    ].join("\n")
+    expect(actual).to eq(expected)
+  end
+
+end

data/spec/response/adapter/json_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Backframe::Response::Adapter::Json do
+
+  before(:all) do
+    @records = [
+      { id: 1, first_name: 'Greg', last_name: 'Kops', email: 'greg@thinktopography.com', photo: { id: 1, path: '/images/greg.jpg' } },
+      { id: 2, first_name: 'Megan', last_name: 'Pugh', email: 'megan@thinktopography.com', photo: { id: 2, path: '/images/megan.jpg' } },
+      { id: 3, first_name: 'Kath', last_name: 'Tibbetts', email: 'kath@thinktopography.com', photo: { id: 3, path: '/images/kath.jpg' } },
+      { id: 4, first_name: 'Armand', last_name: 'Zerilli', email: 'armand@thinktopography.com', photo: { id: 4, path: '/images/armand.jpg' } }
+    ]
+  end
+
+  it 'renders full payload' do
+    collection = Backframe::Response::Collection.new(Backframe::Fixtures::Contact, nil, nil)
+    fields = Backframe::Response::Fields.new(Backframe::Fixtures::Contact, nil)
+    actual = Backframe::Response::Adapter::Json.render(collection, fields)
+    expected = {
+      records: @records,
+      total_records: 4,
+      current_page: 1,
+      total_pages: 1
+    }
+    expect(actual).to eq(expected)
+  end
+
+  it 'renders with a single simple key' do
+    collection = Backframe::Response::Collection.new(Backframe::Fixtures::Contact, nil, nil)
+    fields = Backframe::Response::Fields.new(Backframe::Fixtures::Contact, 'first_name')
+    actual = Backframe::Response::Adapter::Json.render(collection, fields)
+    expected = {
+      records: @records.map { |r| { first_name: r[:first_name] } },
+      total_records: 4,
+      current_page: 1,
+      total_pages: 1
+    }
+    expect(actual).to eq(expected)
+  end
+
+  it 'renders with a single nested key' do
+    collection = Backframe::Response::Collection.new(Backframe::Fixtures::Contact, nil, nil)
+    fields = Backframe::Response::Fields.new(Backframe::Fixtures::Contact, 'photo.id')
+    actual = Backframe::Response::Adapter::Json.render(collection, fields)
+    expected = {
+      records: @records.map { |r| { photo: { id: r[:photo][:id] } } },
+      total_records: 4,
+      current_page: 1,
+      total_pages: 1
+    }
+    expect(actual).to eq(expected)
+  end
+
+  it 'renders with pagination' do
+    collection = Backframe::Response::Collection.new(Backframe::Fixtures::Contact, 1, 2)
+    fields = Backframe::Response::Fields.new(Backframe::Fixtures::Contact, nil)
+    actual = Backframe::Response::Adapter::Json.render(collection, fields)
+    expected = {
+      records: @records[0, 2],
+      total_records: 4,
+      current_page: 1,
+      total_pages: 2
+    }
+    expect(actual).to eq(expected)
+  end
+
+end

data/spec/response/adapter/xlsx_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Backframe::Response::Adapter::Xlsx do
+
+  it 'renders full payload' do
+    collection = Backframe::Response::Collection.new(Backframe::Fixtures::Contact, nil, nil)
+    fields = Backframe::Response::Fields.new(Backframe::Fixtures::Contact, nil)
+    actual = Backframe::Response::Adapter::Xlsx.render(collection, fields)
+    File.open('tmp.xlsx', 'w') { |file| file.write(actual) }
+    xlsx = Roo::Excelx.new('tmp.xlsx')
+    expect(xlsx.sheet(0).row(1)).to eq(["id", "first_name", "last_name", "email", "photo.id", "photo.path"])
+    expect(xlsx.sheet(0).row(2)).to eq(["1", "Greg", "Kops", "greg@thinktopography.com", "1", "/images/greg.jpg"])
+    expect(xlsx.sheet(0).row(3)).to eq(["2", "Megan", "Pugh", "megan@thinktopography.com", "2", "/images/megan.jpg"])
+    expect(xlsx.sheet(0).row(4)).to eq(["3", "Kath", "Tibbetts", "kath@thinktopography.com", "3", "/images/kath.jpg"])
+    expect(xlsx.sheet(0).row(5)).to eq(["4", "Armand", "Zerilli", "armand@thinktopography.com", "4", "/images/armand.jpg"])
+    File.unlink('tmp.xlsx')
+  end
+
+  it 'renders with a single simple key' do
+    collection = Backframe::Response::Collection.new(Backframe::Fixtures::Contact, nil, nil)
+    fields = Backframe::Response::Fields.new(Backframe::Fixtures::Contact, 'first_name')
+    actual = Backframe::Response::Adapter::Xlsx.render(collection, fields)
+    File.open('tmp.xlsx', 'w') { |file| file.write(actual) }
+    xlsx = Roo::Excelx.new('tmp.xlsx')
+    expect(xlsx.sheet(0).row(1)).to eq(["first_name"])
+    expect(xlsx.sheet(0).row(2)).to eq(["Greg"])
+    expect(xlsx.sheet(0).row(3)).to eq(["Megan"])
+    expect(xlsx.sheet(0).row(4)).to eq(["Kath"])
+    expect(xlsx.sheet(0).row(5)).to eq(["Armand"])
+    File.unlink('tmp.xlsx')
+  end
+
+  it 'renders with a single nested key' do
+    collection = Backframe::Response::Collection.new(Backframe::Fixtures::Contact, nil, nil)
+    fields = Backframe::Response::Fields.new(Backframe::Fixtures::Contact, 'photo.id')
+    actual = Backframe::Response::Adapter::Xlsx.render(collection, fields)
+    File.open('tmp.xlsx', 'w') { |file| file.write(actual) }
+    xlsx = Roo::Excelx.new('tmp.xlsx')
+    expect(xlsx.sheet(0).row(1)).to eq(["photo.id"])
+    expect(xlsx.sheet(0).row(2)).to eq(["1"])
+    expect(xlsx.sheet(0).row(3)).to eq(["2"])
+    expect(xlsx.sheet(0).row(4)).to eq(["3"])
+    expect(xlsx.sheet(0).row(5)).to eq(["4"])
+    File.unlink('tmp.xlsx')
+  end
+
+  it 'renders with pagination' do
+    collection = Backframe::Response::Collection.new(Backframe::Fixtures::Contact, 1, 2)
+    fields = Backframe::Response::Fields.new(Backframe::Fixtures::Contact, nil)
+    actual = Backframe::Response::Adapter::Xlsx.render(collection, fields)
+    File.open('tmp.xlsx', 'w') { |file| file.write(actual) }
+    xlsx = Roo::Excelx.new('tmp.xlsx')
+    expect(xlsx.sheet(0).row(1)).to eq(["id", "first_name", "last_name", "email", "photo.id", "photo.path"])
+    expect(xlsx.sheet(0).row(2)).to eq(["1", "Greg", "Kops", "greg@thinktopography.com", "1", "/images/greg.jpg"])
+    expect(xlsx.sheet(0).row(3)).to eq(["2", "Megan", "Pugh", "megan@thinktopography.com", "2", "/images/megan.jpg"])
+    File.unlink('tmp.xlsx')
+  end
+
+end

data/spec/response/adapter/xml_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Backframe::Response::Adapter::Xml do
+
+  it 'renders full payload' do
+    collection = Backframe::Response::Collection.new(Backframe::Fixtures::Contact, nil, nil)
+    fields = Backframe::Response::Fields.new(Backframe::Fixtures::Contact, nil)
+    actual = Backframe::Response::Adapter::Xml.render(collection, fields)
+    expected = [
+      '<?xml version="1.0"?><records>',
+      '<record><id>1</id><first_name>Greg</first_name><last_name>Kops</last_name><email>greg@thinktopography.com</email><photo.id>1</photo.id><photo.path>/images/greg.jpg</photo.path></record>',
+      '<record><id>2</id><first_name>Megan</first_name><last_name>Pugh</last_name><email>megan@thinktopography.com</email><photo.id>2</photo.id><photo.path>/images/megan.jpg</photo.path></record>',
+      '<record><id>3</id><first_name>Kath</first_name><last_name>Tibbetts</last_name><email>kath@thinktopography.com</email><photo.id>3</photo.id><photo.path>/images/kath.jpg</photo.path></record>',
+      '<record><id>4</id><first_name>Armand</first_name><last_name>Zerilli</last_name><email>armand@thinktopography.com</email><photo.id>4</photo.id><photo.path>/images/armand.jpg</photo.path></record>',
+      '</records>'
+    ].join
+    expect(actual).to eq(expected)
+  end
+
+  it 'renders with a single simple key' do
+    collection = Backframe::Response::Collection.new(Backframe::Fixtures::Contact, nil, nil)
+    fields = Backframe::Response::Fields.new(Backframe::Fixtures::Contact, 'first_name')
+    actual = Backframe::Response::Adapter::Xml.render(collection, fields)
+    expected = [
+      '<?xml version="1.0"?><records>',
+      '<record><first_name>Greg</first_name></record>',
+      '<record><first_name>Megan</first_name></record>',
+      '<record><first_name>Kath</first_name></record>',
+      '<record><first_name>Armand</first_name></record>',
+      '</records>'
+    ].join
+    expect(actual).to eq(expected)
+  end
+
+  it 'renders with a single nested key' do
+    collection = Backframe::Response::Collection.new(Backframe::Fixtures::Contact, nil, nil)
+    fields = Backframe::Response::Fields.new(Backframe::Fixtures::Contact, 'photo.id')
+    actual = Backframe::Response::Adapter::Xml.render(collection, fields)
+    expected = [
+      '<?xml version="1.0"?><records>',
+      '<record><photo.id>1</photo.id></record>',
+      '<record><photo.id>2</photo.id></record>',
+      '<record><photo.id>3</photo.id></record>',
+      '<record><photo.id>4</photo.id></record>',
+      '</records>'
+    ].join
+    expect(actual).to eq(expected)
+  end
+
+  it 'renders with pagination' do
+    collection = Backframe::Response::Collection.new(Backframe::Fixtures::Contact, 1, 2)
+    fields = Backframe::Response::Fields.new(Backframe::Fixtures::Contact, nil)
+    actual = Backframe::Response::Adapter::Xml.render(collection, fields)
+    expected = [
+      '<?xml version="1.0"?><records>',
+      '<record><id>1</id><first_name>Greg</first_name><last_name>Kops</last_name><email>greg@thinktopography.com</email><photo.id>1</photo.id><photo.path>/images/greg.jpg</photo.path></record>',
+      '<record><id>2</id><first_name>Megan</first_name><last_name>Pugh</last_name><email>megan@thinktopography.com</email><photo.id>2</photo.id><photo.path>/images/megan.jpg</photo.path></record>',
+      '</records>'
+    ].join
+    expect(actual).to eq(expected)
+  end
+
+end