acfs 1.3.2 → 1.3.3

data/spec/acfs/resource/attributes/list_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe Acfs::Resource::Attributes::List do
-  let(:type) { Acfs::Resource::Attributes::List.new }
-
-  describe '#cast' do
-    subject { -> { type.cast value } }
-
-    context 'with nil' do
-      let(:value) { nil }
-      it { expect(subject.call).to eq nil }
-    end
-
-    context 'with blank string (I)' do
-      let(:value) { '' }
-      it { expect(subject.call).to eq Array.new }
-    end
-
-    context 'with blank string (II)' do
-      let(:value) { "  \t" }
-      it { expect(subject.call).to eq Array.new }
-    end
-
-    context 'with array' do
-      let(:value) { %w(abc cde efg) }
-      it { expect(subject.call).to eq value }
-    end
-
-    context 'with convertable object (I)' do
-      let(:value) do
-        Class.new do
-          def to_ary
-            [1, 2, 3]
-          end
-        end.new
-      end
-
-      it { expect(subject.call).to eq [1, 2, 3] }
-    end
-
-    context 'with convertable object (II)' do
-      let(:value) do
-        Class.new do
-          def to_a
-            [1, 2, 3]
-          end
-        end.new
-      end
-
-      it { expect(subject.call).to eq [1, 2, 3] }
-    end
-
-    context 'with non castable object' do
-      let(:value) { Object.new }
-      it { expect(subject.call).to eq [value] }
-    end
-  end
-end

data/spec/acfs/resource/attributes/uuid_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe Acfs::Resource::Attributes::UUID do
-  let(:type) { Acfs::Resource::Attributes::UUID.new }
-
-  describe '#cast' do
-    subject { -> { type.cast(value) } }
-
-    context 'with nil' do
-      let(:value) { nil }
-      it { expect(subject.call).to eq nil }
-    end
-
-    context 'with empty string' do
-      let(:value) { '' }
-      it { expect(subject.call).to eq nil }
-    end
-
-    context 'with blank string' do
-      let(:value) { "  \t" }
-      it { expect(subject.call).to eq nil }
-    end
-
-    context 'with string UUID' do
-      let(:value) { '450b7a40-94ad-11e3-baa8-0800200c9a66' }
-      it { expect(subject.call).to be_a String }
-      it { expect(subject.call).to eq value }
-    end
-
-    context 'with invalid string' do
-      let(:value) { 'invalid string' }
-      it { is_expected.to raise_error TypeError, /invalid UUID/i }
-    end
-
-    context 'with invalid UUID' do
-      let(:value) { 'xxxxxxxx-yyyy-11e3-baa8-0800200c9a66' }
-      it { is_expected.to raise_error TypeError, /invalid UUID/i }
-    end
-  end
-end

data/spec/acfs/resource/attributes_spec.rb

@@ -1,179 +0,0 @@
-require 'spec_helper'
-
-describe Acfs::Resource::Attributes do
-  let(:model) { Class.new Acfs::Resource }
-  let(:submodel) { Class.new model }
-
-  describe '#initialize' do
-    before { model.attribute :name, :string, default: 'John' }
-
-    it 'should have attribute list' do
-      expect(model.new.attributes).to include(:name)
-    end
-
-    it 'should set default attributes' do
-      expect(model.new.name).to be == 'John'
-    end
-
-    context 'with dynamic default value' do
-      before do
-        model.attribute :name, :string, default: 'John'
-        model.attribute :mail, :string, default: -> { "#{name}@srv.tld" }
-      end
-
-      it 'should set dynamic default attributes' do
-        expect(model.new.mail).to be == 'John@srv.tld'
-      end
-    end
-  end
-
-  describe '#attributes' do
-    before do
-      model.attribute :name, :string, default: 'John'
-      model.attribute :age, :integer, default: 25
-    end
-
-    it 'should return hash of all attributes' do
-      expect(model.new.attributes).to eq(name: 'John', age: 25)
-    end
-  end
-
-  describe '#write_attributes' do
-    before do
-      model.attribute :name, :string, default: 'John'
-      model.attribute :age, :integer, default: 25
-      model.send :define_method, :name= do |name|
-        write_attribute :name, "The Great #{name}"
-      end
-    end
-    let(:args) { [params] }
-    let(:params) { {name: 'James'} }
-    let(:m) { model.new }
-    let(:action) { -> { m.write_attributes(*args) } }
-    subject { action }
-
-    it 'should update attributes'  do
-      should change(m, :attributes)
-        .from(name: 'The Great John', age: 25)
-        .to(name: 'The Great James', age: 25)
-    end
-
-    context 'without non-hash params' do
-      let(:params) { 'James' }
-
-      it { should_not change(m, :attributes) }
-      its(:call) { should eq false }
-    end
-
-    context 'with unknown attributes' do
-      let(:params) { {name: 'James', born_at: 'today'} }
-
-      it { should_not raise_error }
-
-      it 'should update known attributes and store unknown'  do
-        should change(m, :attributes)
-          .from(name: 'The Great John', age: 25)
-          .to(name: 'The Great James', age: 25, born_at: 'today')
-      end
-
-      context 'with unknown: :raise option' do
-        let(:args) { [params, {unknown: :raise}] }
-
-        it { should raise_error(ArgumentError, /unknown attribute/i) }
-
-        it do
-          expect do
-            begin
-              subject.call
-            rescue
-              true
-            end
-          end.to_not change(m, :attributes)
-        end
-      end
-    end
-  end
-
-  describe '#_getter_' do
-    before { model.attribute :name, :string, default: 'John' }
-
-    it 'should return value' do
-      mo = model.new
-      mo.name = 'Paul'
-
-      expect(mo.name).to be == 'Paul'
-    end
-
-    it 'should return default value' do
-      expect(model.new.name).to be == 'John'
-    end
-  end
-
-  describe '#_setter_' do
-    before do
-      model.attribute :name, :string, default: 'John'
-      model.attribute :age, :integer, default: '25'
-    end
-
-    it 'should set value' do
-      o = model.new
-      o.name = 'Paul'
-
-      expect(o.name).to be == 'Paul'
-    end
-
-    it 'should update attributes hash' do
-      o = model.new
-      o.name = 'Johannes'
-
-      expect(o.attributes['name']).to be == 'Johannes'
-    end
-
-    it 'should cast values' do
-      o = model.new
-      o.age = '28'
-
-      expect(o.age).to be == 28
-    end
-  end
-
-  describe 'class' do
-    describe '#attributes' do
-      it 'should add an attribute to model attribute list' do
-        model.send :attribute, :name, :string
-
-        expect(model.attributes.symbolize_keys).to eq name: nil
-      end
-
-      it 'should accept a default value' do
-        model.send :attribute, :name, :string, default: 'John'
-
-        expect(model.attributes.symbolize_keys).to eq name: 'John'
-      end
-
-      it 'should accept a symbolic type' do
-        model.send :attribute, :age, :integer, default: '12'
-
-        expect(model.attributes.symbolize_keys).to eq age: 12
-      end
-
-      it 'should accept a class type' do
-        model.send :attribute, :age, Acfs::Resource::Attributes::Integer,
-          default: '12'
-
-        expect(model.attributes.symbolize_keys).to eq age: 12
-      end
-
-      context 'on inherited resources' do
-        before do
-          model.attribute :age, :integer, default: 5
-          submodel.attribute :born_at, :date_time
-        end
-
-        it 'includes superclass attributes' do
-          expect(submodel.attributes.keys).to match_array %w(age born_at)
-        end
-      end
-    end
-  end
-end

data/spec/acfs/resource/dirty_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-describe Acfs::Resource::Dirty do
-  let(:model) { MyUser.new }
-  before do
-    stub_request(:get, 'http://users.example.org/users/1')
-      .to_return response id: 1, name: 'Anon', age: 12
-    stub_request(:post, 'http://users.example.org/users')
-      .to_return response id: 5, name: 'dhh', age: 12
-  end
-
-  it 'includes ActiveModel::Dirty' do
-    model.is_a? ActiveModel::Dirty
-  end
-
-  describe '#changed?' do
-    context 'after attribute change' do
-      let(:user) { MyUser.new name: 'dhh' }
-
-      it { expect(user).to be_changed }
-
-      context 'and saving' do
-        before { user.save }
-        it { expect(user).to_not be_changed }
-      end
-    end
-
-    context 'after model load' do
-      let(:user) { MyUser.find 1 }
-      before { user && Acfs.run }
-
-      it { expect(user).to_not be_changed }
-    end
-
-    context 'after model new without attrs' do
-      let(:user) { MyUser.new }
-
-      it { expect(user).to_not be_changed }
-    end
-
-    context 'after model new with attrs' do
-      let(:user) { MyUser.new name: 'Uschi' }
-
-      it { expect(user).to be_changed }
-    end
-  end
-end

data/spec/acfs/resource/initialization_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-describe 'Acfs::Resource::Initialization' do
-  let(:model) do
-    Class.new(Acfs::Resource).tap do |c|
-      c.class_eval do
-        attr_accessor :name, :age
-        private :age=
-      end
-    end
-  end
-
-  describe '#initialize' do
-    it 'should allow to set attributes with initializer' do
-      m = model.new name: 'John'
-      expect(m.name).to eq 'John'
-    end
-
-    it 'should raise error when attributes with private setters are given' do
-      expect { model.new age: 25 }.to raise_error(NoMethodError)
-    end
-  end
-
-  describe '#persisted?' do
-    subject { model.new.persisted? }
-    it 'should be false' do
-      should be false
-    end
-  end
-end

data/spec/acfs/resource/loadable_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe Acfs::Resource::Loadable do
-  let(:model) { MyUser.find 1 }
-  before do
-    stub_request(:get, 'http://users.example.org/users/1')
-      .to_return response id: 1, name: 'Anon', age: 12
-  end
-
-  describe '#loaded?' do
-    context 'before Acfs#run' do
-      it { expect(model).to_not be_loaded }
-    end
-
-    context 'afer Acfs#run' do
-      before { model && Acfs.run }
-      it { expect(model).to be_loaded }
-    end
-  end
-end

data/spec/acfs/resource/locatable_spec.rb

@@ -1,116 +0,0 @@
-require 'spec_helper'
-
-describe Acfs::Resource::Locatable do
-  let(:model) { MyUser }
-  before do
-    stub_request(:get, 'http://users.example.org/users/1')
-      .to_return response id: 1, name: 'Anon', age: 12
-    stub_request(:get, 'http://users.example.org/users/1/profile')
-      .to_return response user_id: 2, twitter_handle: '@anon'
-  end
-
-  describe '.url' do
-    it 'should return URL' do
-      expect(model.url).to be == 'http://users.example.org/users'
-    end
-
-    it 'should return URL with id path part if specified' do
-      expect(model.url(5)).to be == 'http://users.example.org/users/5'
-    end
-
-    context 'with attribute in path' do
-      let(:model) { Profile }
-
-      it 'should replace placeholder' do
-        expect(model.url(user_id: 1))
-          .to eq 'http://users.example.org/users/1/profile'
-      end
-
-      context 'without attributes' do
-        it 'should raise an error if attribute is missing' do
-          expect { model.url }.to raise_error ArgumentError
-        end
-      end
-    end
-
-    describe 'custom paths' do
-      let(:model) { Session }
-      let(:location) { Session.location action: action }
-      subject { location }
-
-      context ':list location' do
-        let(:action) { :list }
-
-        its(:raw_uri) do
-          should eq 'http://users.example.org/users/:user_id/sessions'
-        end
-      end
-
-      context ':create location' do
-        let(:action) { :create }
-        its(:raw_uri) { should eq 'http://users.example.org/sessions' }
-      end
-
-      context ':read location' do
-        let(:action) { :read }
-        its(:raw_uri) { should eq 'http://users.example.org/sessions/:id' }
-      end
-
-      context ':update location' do
-        let(:action) { :update }
-        its(:raw_uri) do
-          expect { subject }.to raise_error ArgumentError, /update.*disabled/
-        end
-      end
-
-      context ':delete location' do
-        let(:action) { :delete }
-        its(:raw_uri) do
-          should eq 'http://users.example.org/users/:user_id/sessions/del/:id'
-        end
-      end
-    end
-  end
-
-  describe '#url' do
-    context 'new resource' do
-      let(:m) { model.new }
-
-      it 'should return nil' do
-        expect(m.url).to be_nil
-      end
-
-      context 'new resource with id' do
-        let(:m) { model.new id: 475 }
-
-        it 'should return resource URL' do
-          expect(m.url).to eq 'http://users.example.org/users/475'
-        end
-      end
-
-      context 'with attribute in path' do
-        it 'should return nil' do
-          expect(m.url).to be_nil
-        end
-      end
-    end
-
-    context 'loaded resource' do
-      let(:m) { model.find 1 }
-      before { m && Acfs.run }
-
-      it "should return resource's URL" do
-        expect(m.url).to eq 'http://users.example.org/users/1'
-      end
-
-      context 'with attribute in path' do
-        let(:model) { Profile }
-        let(:m) { model.find user_id: 1 }
-
-        it "should return resource's URL" do
-          expect(m.url).to eq 'http://users.example.org/users/2/profile'
-        end
-      end
-    end
-  end
-end