acfs 1.3.3 → 1.3.4

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+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

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+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 StandardError
+              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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+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
+        attr_reader :age
+
+        private
+
+        attr_writer :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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+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