flydata 0.0.4.4 → 0.0.5.0

data/spec/fly_data_model_spec.rb

@@ -0,0 +1,250 @@
+require 'spec_helper'
+require 'stringio'
+
+if defined? ActiveModel
+  # TestUserModel model
+  class TestUserModel
+    include FlyDataModel
+    attr_accessor :name, :birthday, :timestamp
+
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end
+    end
+
+    def attributes
+      {
+        'name' => name,
+        'birthday' => birthday,
+        'timestamp' => timestamp,
+      }
+    end
+  end
+
+  # TestOrderModel model
+  class TestOrderModel
+    include FlyDataModel
+    attr_accessor :user_id, :item, :quantity, :purchased_on, :timestamp
+
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end
+    end
+
+    def attributes
+      {
+        'user_id' => user_id,
+        'item' => item,
+        'quantity' => quantity,
+        'purchased_on' => purchased_on,
+        'timestamp' => timestamp,
+      }
+    end
+  end
+
+  # TestOrder model with configured table name and attributes
+  class ConfiguredTestOrderModel < TestOrderModel
+    flydata_table :other_table
+    flydata_attr :item, :quantity
+  end
+end
+
+describe Flydata do
+
+  describe '.send_to' do
+    before do
+      # Use ActiveSupport::TimeWithZone
+      Time.zone = 'Japan'
+    end
+
+    describe 'ActiveModel support' do
+      context '1st argument is includes ActiveModel::Serialization' do
+        let(:first_argument) do
+          TestOrderModel.new(user_id: 2,
+                             item: 'orange',
+                             quantity: 6,
+                             purchased_on: Date.new(2013, 6, 1),
+                             timestamp: Time.local(2013, 6, 1, 11, 22, 33))
+        end
+
+        it 'puts a JSON string represents 1st argument' do
+          actual = capture(:stdout) { described_class.send_to(first_argument) }.chomp
+          json = <<-EOS
+              {
+                  "test_order_models": {
+                      "item": "orange",
+                      "purchased_on": "2013-06-01",
+                      "quantity": 6,
+                      "timestamp": "2013-06-01 11:22:33",
+                      "user_id": 2
+                  }
+              }
+            EOS
+          expectation = JSON.parse(json).to_json
+          expect(actual).to eq(expectation)
+        end
+      end
+
+      context '1st argument is an Array of models which includes ActiveModel::Serialization' do
+        let(:first_argument) do
+          [
+           TestOrderModel.new(user_id: 2,
+                              item: 'orange',
+                              quantity: 6,
+                              purchased_on: Date.new(2013, 6, 1),
+                              timestamp: Time.local(2013, 6, 1, 11, 22, 33)),
+           TestOrderModel.new(user_id: 2,
+                              item: 'banana',
+                              quantity: 12,
+                              purchased_on: Date.new(2013, 7, 1),
+                              timestamp: Time.local(2013, 7, 1, 11, 22, 33)),
+          ]
+        end
+
+        it 'puts a JSON string represents 1st argument' do
+          actual = capture(:stdout) { described_class.send_to(first_argument) }.chomp
+          json = <<-EOS
+              {
+                  "test_order_models": [{
+                          "item": "orange",
+                          "purchased_on": "2013-06-01",
+                          "quantity": 6,
+                          "timestamp": "2013-06-01 11:22:33",
+                          "user_id": 2
+                      }, {
+                          "item": "banana",
+                          "purchased_on": "2013-07-01",
+                          "quantity": 12,
+                          "timestamp": "2013-07-01 11:22:33",
+                          "user_id": 2
+                      }
+                  ]
+              }
+            EOS
+          expectation = JSON.parse(json).to_json
+          expect(actual).to eq(expectation)
+        end
+      end
+
+      context 'Arguments are including ActiveModel::Base' do
+        let(:first_argument) {
+          TestOrderModel.new(user_id: 2,
+                             item: 'orange',
+                             quantity: 6,
+                             purchased_on: Date.new(2013, 6, 1),
+                             timestamp: Time.local(2013, 6, 1, 11, 22, 33))
+        }
+        let(:second_argument) {
+          TestOrderModel.new(user_id: 2,
+                             item: 'banana',
+                             quantity: 12,
+                             purchased_on: Date.new(2013, 7, 1),
+                             timestamp: Time.local(2013, 7, 1, 11, 22, 33))
+        }
+        let(:third_argument) { TestUserModel.new(name: 'John') }
+
+        it 'puts a JSON string represents all arguments' do
+          actual = capture(:stdout) do
+            described_class.send_to(first_argument,
+                                    second_argument,
+                                    third_argument)
+          end.chomp
+          json = <<-EOS
+              {
+                  "test_order_models": [{
+                          "item": "orange",
+                          "purchased_on": "2013-06-01",
+                          "quantity": 6,
+                          "timestamp": "2013-06-01 11:22:33",
+                          "user_id": 2
+                      },
+                      {
+                          "item": "banana",
+                          "purchased_on": "2013-07-01",
+                          "quantity": 12,
+                          "timestamp": "2013-07-01 11:22:33",
+                          "user_id": 2
+                      }
+                  ],
+                  "test_user_models": {
+                      "birthday": null,
+                      "name": "John",
+                      "timestamp": null
+                  }
+              }
+            EOS
+          expectation = JSON.parse(json).to_json
+          expect(actual).to eq(expectation)
+        end
+      end
+    end
+  end
+
+  if defined? ActiveModel
+    describe 'ActiveModel::Serialization#send_to_flydata' do
+      let(:order) do
+        TestOrderModel.new(user_id: 2,
+                           item: 'orange',
+                           quantity: 6,
+                           purchased_on: Date.new(2013, 6, 1),
+                           timestamp: Time.local(2013, 6, 1, 11, 22, 33))
+      end
+
+      it 'puts a JSON string represents a model' do
+        actual = capture(:stdout) { order.send_to_flydata }.chomp
+        json = <<-EOS
+          {
+              "test_orders": {
+                  "item": "orange",
+                  "purchased_on": "2013-06-01",
+                  "quantity": 6,
+                  "timestamp": "2013-06-01 11:22:33",
+                  "user_id": 2
+              }
+          }
+        EOS
+        expectation = JSON.parse(json).to_json
+      end
+    end
+
+    describe 'ActiveModel::Serialization.flydata_table' do
+      let(:order) {
+        ConfiguredTestOrderModel.new(user_id: 2, item: 'orange', quantity: 6)
+      }
+
+      it 'puts a JSON string represents a model to configured table name' do
+        output = capture(:stdout) { order.send_to_flydata }
+        actual = JSON.parse(output)
+        expect(actual.keys).to include('other_table')
+        expect(actual.keys).not_to include('test_orders')
+      end
+    end
+
+    describe 'ActiveModel::Serialization.flydata_attr' do
+      let(:order) { ConfiguredTestOrderModel.new(user_id: 2, item: 'orange', quantity: 6) }
+
+      it 'puts a JSON string represents a model to configured attributes' do
+        output = capture(:stdout) { order.send_to_flydata }
+        actual = JSON.parse(output)
+        expect(actual['other_table'].keys).to include('item')
+        expect(actual['other_table'].keys).to include('quantity')
+        expect(actual['other_table'].keys).not_to include('purchased_on')
+        expect(actual['other_table'].keys).not_to include('timestamp')
+        expect(actual['other_table'].keys).not_to include('user_id')
+      end
+
+      context 'without attributes' do
+        it 'raise exception' do
+          expect {
+            class InvalidConfiguredTestOrderModel < TestOrderModel
+              flydata_attr
+            end
+          }.to raise_error(RuntimeError, 'flydata_attr attributes cannot be blank')
+        end
+      end
+    end
+  end
+
+end

data/spec/flydata/heroku_spec.rb

@@ -0,0 +1,668 @@
+require 'spec_helper'
+require 'stringio'
+
+if defined? ActiveRecord
+  # Prepare for tests ActiveRecord
+  ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ':memory:'
+
+  # Database migrations
+  ActiveRecord::Migration.create_table :test_users do |t|
+    t.string :name
+    t.date :birthday
+    t.timestamp :timestamp
+  end
+  ActiveRecord::Migration.create_table :test_orders do |t|
+    t.references :user
+    t.string :item
+    t.integer :quantity
+    t.date :purchased_on
+    t.timestamp :timestamp
+  end
+
+  # TestUser model
+  class TestUser < ActiveRecord::Base
+    attr_accessible :id, :name, :birthday, :timestamp
+    has_many :orders
+  end
+
+  # TestOrder model
+  class TestOrder < ActiveRecord::Base
+    attr_accessible :id, :user_id, :item, :quantity, :purchased_on, :timestamp
+    belongs_to :user
+  end
+
+  # TestOrder model with configured table name and attributes
+  class ConfiguredTestOrder < TestOrder
+    flydata_table :other_table
+    flydata_attr :id, :item, :purchased_on, :timestamp
+  end
+end
+
+if defined? ActiveModel
+  # TestUserModel model
+  class TestUserModel
+    include ActiveModel::Serialization
+    attr_accessor :name, :birthday, :timestamp
+
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end
+    end
+
+    def attributes
+      {
+        'name' => name,
+        'birthday' => birthday,
+        'timestamp' => timestamp,
+      }
+    end
+  end
+
+  # TestOrderModel model
+  class TestOrderModel
+    include ActiveModel::Serialization
+    attr_accessor :user_id, :item, :quantity, :purchased_on, :timestamp
+
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end
+    end
+
+    def attributes
+      {
+        'user_id' => user_id,
+        'item' => item,
+        'quantity' => quantity,
+        'purchased_on' => purchased_on,
+        'timestamp' => timestamp,
+      }
+    end
+  end
+
+  # TestOrder model with configured table name and attributes
+  class ConfiguredTestOrderModel < TestOrderModel
+    flydata_table :other_table
+    flydata_attr :item, :quantity
+  end
+end
+
+# Captures and returns output to specified stream.
+def capture(stream)
+  begin
+    stream = stream.to_s
+    eval "$#{stream} = StringIO.new"
+    yield
+    result = eval("$#{stream}").string
+  ensure
+    eval "$#{stream} = #{stream.upcase}"
+  end
+  result
+end
+
+describe Flydata do
+
+  describe '.send_to' do
+    before do
+      # Use ActiveSupport::TimeWithZone
+      Time.zone = 'Japan'
+    end
+
+    let(:item_hash) do
+      {
+        id: 1,
+        name: 'orange',
+        date: Date.new(2013, 6, 1),
+        time: Time.local(2013, 6, 1, 11, 22, 33),
+        date_time: Time.local(2013, 6, 1, 11, 22, 33).to_datetime,
+        time_with_zone: Time.zone.local(2013, 6, 1, 11, 22, 33),
+      }
+    end
+    let(:item_hash_json) do
+      json = <<-EOS
+        {
+            "items": {
+                "id": 1,
+                "name": "orange",
+                "date": "2013-06-01",
+                "time": "2013-06-01 11:22:33",
+                "date_time": "2013-06-01 11:22:33",
+                "time_with_zone": "2013-06-01 11:22:33"
+            }
+        }
+      EOS
+      JSON.parse(json).to_json
+    end
+
+    let(:item_array) do
+      [
+       {
+         id: 1,
+         name: 'orange',
+         date: Date.new(2013, 6, 1),
+         time: Time.local(2013, 6, 1, 11, 22, 33),
+         date_time: Time.local(2013, 6, 1, 11, 22, 33).to_datetime,
+         time_with_zone: Time.zone.local(2013, 6, 1, 11, 22, 33),
+       },
+       {
+         id: 2,
+         name: 'banana',
+         date: Date.new(2013, 6, 2),
+         time: Time.local(2013, 6, 2, 11, 22, 33),
+         date_time: Time.local(2013, 6, 2, 11, 22, 33).to_datetime,
+         time_with_zone: Time.zone.local(2013, 6, 2, 11, 22, 33),
+       },
+      ]
+    end
+    let(:item_array_json) do
+      json = <<-EOS
+        {
+            "items": [{
+                    "id": 1,
+                    "name": "orange",
+                    "date": "2013-06-01",
+                    "time": "2013-06-01 11:22:33",
+                    "date_time": "2013-06-01 11:22:33",
+                    "time_with_zone": "2013-06-01 11:22:33"
+                }, {
+                    "id": 2,
+                    "name": "banana",
+                    "date": "2013-06-02",
+                    "time": "2013-06-02 11:22:33",
+                    "date_time": "2013-06-02 11:22:33",
+                    "time_with_zone": "2013-06-02 11:22:33"
+                }
+            ]
+        }
+      EOS
+      JSON.parse(json).to_json
+    end
+
+    context '1st argument is a nil' do
+      it 'raises an ArgumentError' do
+        expect {
+          capture(:stdout) { described_class.send_to }
+        }.to raise_error(ArgumentError, 'The argument of send_to must be non-nil')
+      end
+    end
+
+    context '1st argument is a String' do
+      context '1st argument is an empty String' do
+        it 'raises an ArgumentError' do
+          expect {
+            capture(:stdout) { described_class.send_to('') }
+          }.to raise_error(ArgumentError, 'The 1st argument of send_to must not be empty')
+        end
+      end
+
+      context '2nd argument is a Hash' do
+        it 'puts a JSON string' do
+          actual = capture(:stdout) do
+            described_class.send_to('items', item_hash)
+          end.chomp
+          expect(actual).to eq(item_hash_json)
+        end
+      end
+
+      context '2nd argument is an Array' do
+        it 'puts a JSON string' do
+          actual = capture(:stdout) do
+            described_class.send_to('items', item_array)
+          end.chomp
+          expect(actual).to eq(item_array_json)
+        end
+      end
+
+      context '2nd argument is nil' do
+        it 'raises an ArgumentError' do
+          expect {
+            capture(:stdout) { described_class.send_to('items') }
+          }.to raise_error(ArgumentError, 'The 2nd argument of send_to must be an Array or Hash')
+        end
+      end
+
+      context '2nd argument is a String' do
+        it 'raises an ArgumentError' do
+          expect {
+            capture(:stdout) { described_class.send_to('items', 'foo') }
+          }.to raise_error(ArgumentError)
+        end
+      end
+    end
+
+    context '1st argument is kind of a Symbol' do
+      context '1st argument is an empty Symbol' do
+        it 'raises an ArgumentError' do
+          expect {
+            capture(:stdout) { described_class.send_to(:'') }
+          }.to raise_error(ArgumentError, 'The 1st argument of send_to must not be empty')
+        end
+      end
+
+      context '2nd argument is a Hash' do
+        it 'puts a JSON string' do
+          actual = capture(:stdout) do
+            described_class.send_to(:items, item_hash)
+          end.chomp
+          expect(actual).to eq(item_hash_json)
+        end
+      end
+
+      context '2nd argument is an Array' do
+        it 'puts a JSON string' do
+          actual = capture(:stdout) do
+            described_class.send_to(:items, item_array)
+          end.chomp
+          expect(actual).to eq(item_array_json)
+        end
+      end
+    end
+
+    context '1st argument is an empty Array' do
+      it 'raises an ArgumentError' do
+        expect {
+          capture(:stdout) { described_class.send_to([]) }
+        }.to raise_error(ArgumentError, 'The 1st argument of send_to must not be empty')
+      end
+    end
+
+    context '1st argument is an empty Hash' do
+      it 'raises an ArgumentError' do
+        expect {
+          capture(:stdout) { described_class.send_to({}) }
+        }.to raise_error(ArgumentError, 'The 1st argument of send_to must not be empty')
+      end
+    end
+
+    describe 'ActiveRecord support' do
+      let!(:user) do
+        TestUser.create!(name: 'John Doe',
+                         birthday: Date.new(2010, 1, 2),
+                         timestamp: Time.local(2013, 6, 1, 11, 22, 33))
+      end
+      let!(:order1) do
+        TestOrder.create!(user_id: user.id,
+                          item: 'orange',
+                          quantity: 6,
+                          purchased_on: Date.new(2013, 6, 1),
+                          timestamp: Time.local(2013, 6, 1, 11, 22, 33))
+      end
+      let!(:order2) do
+        TestOrder.create!(user_id: user.id,
+                          item: 'banana',
+                          quantity: 12,
+                          purchased_on: Date.new(2013, 6, 2),
+                          timestamp: Time.local(2013, 6, 2, 11, 22, 33))
+      end
+
+      context '1st argument is an ActiveRecord::Base' do
+        let(:first_argument) { order1 }
+
+        it 'puts a JSON string' do
+          actual = capture(:stdout) { described_class.send_to(first_argument) }.chomp
+          json = <<-EOS
+              {
+                  "test_orders": {
+                      "id": #{order1.id},
+                      "item": "orange",
+                      "purchased_on": "2013-06-01",
+                      "quantity": 6,
+                      "timestamp": "2013-06-01 11:22:33",
+                      "user_id": #{user.id}
+                  }
+              }
+            EOS
+          expectation = JSON.parse(json).to_json
+          expect(actual).to eq(expectation)
+        end
+      end
+
+      context '1st argument is an Array of ActiveRecord::Base' do
+        let(:first_argument) { [order1, order2] }
+
+        it 'puts a JSON string' do
+          actual = capture(:stdout) { described_class.send_to(first_argument) }.chomp
+          json = <<-EOS
+              {
+                  "test_orders": [{
+                          "id": #{order1.id},
+                          "item": "orange",
+                          "purchased_on": "2013-06-01",
+                          "quantity": 6,
+                          "timestamp": "2013-06-01 11:22:33",
+                          "user_id": #{user.id}
+                      }, {
+                          "id": #{order2.id},
+                          "item": "banana",
+                          "purchased_on": "2013-06-02",
+                          "quantity": 12,
+                          "timestamp": "2013-06-02 11:22:33",
+                          "user_id": #{user.id}
+                      }
+                  ]
+              }
+            EOS
+          expectation = JSON.parse(json).to_json
+          expect(actual).to eq(expectation)
+        end
+      end
+
+      context 'Arguments are ActiveRecord::Base' do
+        let(:first_argument) { user }
+        let(:second_argument) { order1 }
+        let(:third_argument) { order2 }
+
+        it 'puts a JSON string represents all arguments' do
+          actual = capture(:stdout) do
+            described_class.send_to(first_argument,
+                                    second_argument,
+                                    third_argument)
+          end.chomp
+
+          json = <<-EOS
+              {
+                  "test_orders": [{
+                          "id": #{order1.id},
+                          "item": "orange",
+                          "purchased_on": "2013-06-01",
+                          "quantity": 6,
+                          "timestamp": "2013-06-01 11:22:33",
+                          "user_id": #{user.id}
+                      }, {
+                          "id": #{order2.id},
+                          "item": "banana",
+                          "purchased_on": "2013-06-02",
+                          "quantity": 12,
+                          "timestamp": "2013-06-02 11:22:33",
+                          "user_id": #{user.id}
+                      }
+                  ],
+                  "test_users": {
+                      "birthday": "2010-01-02",
+                      "id": #{user.id},
+                      "name": "John Doe",
+                      "timestamp": "2013-06-02 11:22:33"
+                  }
+              }
+            EOS
+          expectation = JSON.parse(json).to_json
+        end
+      end
+    end
+
+    describe 'ActiveModel support' do
+      context '1st argument is includes ActiveModel::Serialization' do
+        let(:first_argument) do
+          TestOrderModel.new(user_id: 2,
+                             item: 'orange',
+                             quantity: 6,
+                             purchased_on: Date.new(2013, 6, 1),
+                             timestamp: Time.local(2013, 6, 1, 11, 22, 33))
+        end
+
+        it 'puts a JSON string represents 1st argument' do
+          actual = capture(:stdout) { described_class.send_to(first_argument) }.chomp
+          json = <<-EOS
+              {
+                  "test_order_models": {
+                      "item": "orange",
+                      "purchased_on": "2013-06-01",
+                      "quantity": 6,
+                      "timestamp": "2013-06-01 11:22:33",
+                      "user_id": 2
+                  }
+              }
+            EOS
+          expectation = JSON.parse(json).to_json
+          expect(actual).to eq(expectation)
+        end
+      end
+
+      context '1st argument is an Array of models which includes ActiveModel::Serialization' do
+        let(:first_argument) do
+          [
+           TestOrderModel.new(user_id: 2,
+                              item: 'orange',
+                              quantity: 6,
+                              purchased_on: Date.new(2013, 6, 1),
+                              timestamp: Time.local(2013, 6, 1, 11, 22, 33)),
+           TestOrderModel.new(user_id: 2,
+                              item: 'banana',
+                              quantity: 12,
+                              purchased_on: Date.new(2013, 7, 1),
+                              timestamp: Time.local(2013, 7, 1, 11, 22, 33)),
+          ]
+        end
+
+        it 'puts a JSON string represents 1st argument' do
+          actual = capture(:stdout) { described_class.send_to(first_argument) }.chomp
+          json = <<-EOS
+              {
+                  "test_order_models": [{
+                          "item": "orange",
+                          "purchased_on": "2013-06-01",
+                          "quantity": 6,
+                          "timestamp": "2013-06-01 11:22:33",
+                          "user_id": 2
+                      }, {
+                          "item": "banana",
+                          "purchased_on": "2013-07-01",
+                          "quantity": 12,
+                          "timestamp": "2013-07-01 11:22:33",
+                          "user_id": 2
+                      }
+                  ]
+              }
+            EOS
+          expectation = JSON.parse(json).to_json
+          expect(actual).to eq(expectation)
+        end
+      end
+
+      context 'Arguments are including ActiveModel::Base' do
+        let(:first_argument) {
+          TestOrderModel.new(user_id: 2,
+                             item: 'orange',
+                             quantity: 6,
+                             purchased_on: Date.new(2013, 6, 1),
+                             timestamp: Time.local(2013, 6, 1, 11, 22, 33))
+        }
+        let(:second_argument) {
+          TestOrderModel.new(user_id: 2,
+                             item: 'banana',
+                             quantity: 12,
+                             purchased_on: Date.new(2013, 7, 1),
+                             timestamp: Time.local(2013, 7, 1, 11, 22, 33))
+        }
+        let(:third_argument) { TestUserModel.new(name: 'John') }
+
+        it 'puts a JSON string represents all arguments' do
+          actual = capture(:stdout) do
+            described_class.send_to(first_argument,
+                                    second_argument,
+                                    third_argument)
+          end.chomp
+          json = <<-EOS
+              {
+                  "test_order_models": [{
+                          "item": "orange",
+                          "purchased_on": "2013-06-01",
+                          "quantity": 6,
+                          "timestamp": "2013-06-01 11:22:33",
+                          "user_id": 2
+                      },
+                      {
+                          "item": "banana",
+                          "purchased_on": "2013-07-01",
+                          "quantity": 12,
+                          "timestamp": "2013-07-01 11:22:33",
+                          "user_id": 2
+                      }
+                  ],
+                  "test_user_models": {
+                      "birthday": null,
+                      "name": "John",
+                      "timestamp": null
+                  }
+              }
+            EOS
+          expectation = JSON.parse(json).to_json
+          expect(actual).to eq(expectation)
+        end
+      end
+    end
+  end
+
+  if defined? ActiveRecord
+    describe 'ActiveRecord::Base#send_to_flydata' do
+      let(:order) do
+        TestOrder.create!(id: 1,
+                          user_id: 2,
+                          item: 'orange',
+                          quantity: 6,
+                          purchased_on: Date.new(2013, 6, 1),
+                          timestamp: Time.local(2013, 6, 1, 11, 22, 33))
+      end
+
+      it 'puts a JSON string represents a model' do
+        actual = capture(:stdout) { order.send_to_flydata }.chomp
+        json = <<-EOS
+            {
+                "test_orders": {
+                    "id": 1,
+                    "item": "orange",
+                    "purchased_on": "2013-06-01",
+                    "quantity": 6,
+                    "timestamp": "2013-06-01 11:22:33",
+                    "user_id": 2
+                }
+            }
+          EOS
+        expectation = JSON.parse(json).to_json
+        expect(actual).to eq(expectation)
+      end
+    end
+
+    describe 'ActiveRecord::Base.flydata_table' do
+      let(:order) do
+        ConfiguredTestOrder.create!(id: 1,
+                                    user_id: 2,
+                                    item: 'orange',
+                                    quantity: 6,
+                                    purchased_on: Date.new(2013, 6, 1),
+                                    timestamp: Time.local(2013, 6, 1, 11, 22, 33))
+      end
+
+      it 'puts a JSON string represents a model to configured table name' do
+        output = capture(:stdout) { order.send_to_flydata }
+        actual = JSON.parse(output)
+        expect(actual.keys).to include('other_table')
+        expect(actual.keys).not_to include('test_orders')
+      end
+    end
+
+    describe 'ActiveRecord::Base.flydata_attr' do
+      let(:order) do
+        ConfiguredTestOrder.create!(id: 1,
+                                    user_id: 2,
+                                    item: 'orange',
+                                    quantity: 6,
+                                    purchased_on: Date.new(2013, 6, 1),
+                                    timestamp: Time.local(2013, 6, 1, 11, 22, 33))
+      end
+
+      it 'puts a JSON string represents a model to configured attributes' do
+        actual = capture(:stdout) { order.send_to_flydata }.chomp
+        json = <<-EOS
+            {
+                "other_table": {
+                    "id": 1,
+                    "item": "orange",
+                    "purchased_on": "2013-06-01",
+                    "timestamp": "2013-06-01 11:22:33"
+                }
+            }
+          EOS
+        expectation = JSON.parse(json).to_json
+        expect(actual).to eq(expectation)
+      end
+
+      context 'without attributes' do
+        it 'raise exception' do
+          expect {
+            class InvalidConfiguredTestOrder < TestOrder
+              flydata_attr
+            end
+          }.to raise_error(RuntimeError, 'flydata_attr attributes cannot be blank')
+        end
+      end
+    end
+  end
+
+  if defined? ActiveModel
+    describe 'ActiveModel::Serialization#send_to_flydata' do
+      let(:order) do
+        TestOrderModel.new(user_id: 2,
+                           item: 'orange',
+                           quantity: 6,
+                           purchased_on: Date.new(2013, 6, 1),
+                           timestamp: Time.local(2013, 6, 1, 11, 22, 33))
+      end
+
+      it 'puts a JSON string represents a model' do
+        actual = capture(:stdout) { order.send_to_flydata }.chomp
+        json = <<-EOS
+          {
+              "test_orders": {
+                  "item": "orange",
+                  "purchased_on": "2013-06-01",
+                  "quantity": 6,
+                  "timestamp": "2013-06-01 11:22:33",
+                  "user_id": 2
+              }
+          }
+        EOS
+        expectation = JSON.parse(json).to_json
+      end
+    end
+
+    describe 'ActiveModel::Serialization.flydata_table' do
+      let(:order) {
+        ConfiguredTestOrderModel.new(user_id: 2, item: 'orange', quantity: 6)
+      }
+
+      it 'puts a JSON string represents a model to configured table name' do
+        output = capture(:stdout) { order.send_to_flydata }
+        actual = JSON.parse(output)
+        expect(actual.keys).to include('other_table')
+        expect(actual.keys).not_to include('test_orders')
+      end
+    end
+
+    describe 'ActiveModel::Serialization.flydata_attr' do
+      let(:order) { ConfiguredTestOrderModel.new(user_id: 2, item: 'orange', quantity: 6) }
+
+      it 'puts a JSON string represents a model to configured attributes' do
+        output = capture(:stdout) { order.send_to_flydata }
+        actual = JSON.parse(output)
+        expect(actual['other_table'].keys).to include('item')
+        expect(actual['other_table'].keys).to include('quantity')
+        expect(actual['other_table'].keys).not_to include('purchased_on')
+        expect(actual['other_table'].keys).not_to include('timestamp')
+        expect(actual['other_table'].keys).not_to include('user_id')
+      end
+
+      context 'without attributes' do
+        it 'raise exception' do
+          expect {
+            class InvalidConfiguredTestOrderModel < TestOrderModel
+              flydata_attr
+            end
+          }.to raise_error(RuntimeError, 'flydata_attr attributes cannot be blank')
+        end
+      end
+    end
+  end
+
+end