typekit-client 0.0.5 → 0.0.6

data/spec/lib/typekit/element/association_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'fixture/record/article'
+require 'fixture/record/section'
+
+RSpec.describe Typekit::Element::Association do
+  let(:article_class) { Fixture::Record::Article }
+  let(:section_class) { Fixture::Record::Section }
+
+  describe '.has_many' do
+    let(:nested_collection_attributes) do
+      [{ title: 'First' }, { title: 'Second' }]
+    end
+
+    shared_examples 'an adequate collection accessor' do
+      it 'initializes the relation as a Collection' do
+        expect(subject.sections).to be_kind_of(Typekit::Collection::Base)
+      end
+
+      describe 'the Collection' do
+        it 'is based on the attributes' do
+          expect(subject.sections.map(&:title)).to \
+            contain_exactly('First', 'Second')
+        end
+      end
+    end
+
+    it 'defines a getter method' do
+      expect(article_class.new).to respond_to(:sections)
+    end
+
+    describe 'the getter method' do
+      context 'when the attributes of the association are given' do
+        subject { article_class.new(sections: nested_collection_attributes) }
+
+        it_behaves_like 'an adequate collection accessor'
+      end
+
+      context 'when the attributes of the association are not given' do
+        it 'returns an empty Collection when new' do
+          subject = article_class.new
+
+          expect(subject).not_to receive(:load!)
+          expect(subject.sections).to be_kind_of(Typekit::Collection::Base)
+          expect(subject.sections).to be_empty
+        end
+
+        it 'loads the association when not new' do
+          subject = article_class.new(id: 42)
+
+          expect(subject).to receive(:load!).and_throw(:break)
+          catch(:break) { subject.sections }
+        end
+      end
+    end
+
+    it 'defines a setter method' do
+      expect(article_class.new).to respond_to(:sections=)
+    end
+
+    describe 'the setter method' do
+      subject { article_class.new }
+
+      context 'when receives plain attributes' do
+        before(:example) { subject.sections = nested_collection_attributes }
+
+        it_behaves_like 'an adequate collection accessor'
+      end
+
+      context 'when receives arrays of Elements' do
+        before(:example) do
+          subject.sections = nested_collection_attributes.map do |attributes|
+            section_class.new(attributes)
+          end
+        end
+
+        it_behaves_like 'an adequate collection accessor'
+      end
+    end
+  end
+
+  describe '.belongs_to' do
+    it 'defines a getter method' do
+      expect(section_class.new).to respond_to(:article)
+    end
+
+    describe 'the getter method' do
+      context 'when the attributes of the association are not given' do
+        subject { section_class.new }
+
+        it 'returns nil' do
+          expect(subject.article).to be nil
+        end
+      end
+    end
+  end
+end

data/spec/lib/typekit/element/base_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require 'fixture/record/article'
+require 'fixture/record/section'
+
+RSpec.describe Typekit::Element::Base do
+  let(:article_class) { Fixture::Record::Article }
+  let(:section_class) { Fixture::Record::Section }
+
+  describe '#new' do
+    it 'treats options as attributes' do
+      subject = article_class.new(title: 'Awesome')
+      expect { subject.title = 'Superb' }.to \
+        change { subject.title }.from('Awesome').to('Superb')
+    end
+
+    it 'symbolizes the names of the attributes' do
+      subject = article_class.new('title' => 'Awesome')
+      expect(subject.attributes.keys).to include(:title)
+    end
+
+    it 'appends the id attribute when missing' do
+      subject = article_class.new(title: 'Awesome')
+      expect(subject.id).to be nil
+    end
+
+    it 'does not affect the id attribute when present' do
+      subject = article_class.new(id: 42, title: 'Awesome')
+      expect(subject.id).to be 42
+    end
+  end
+
+  describe '#attributes' do
+    it 'returns all attributes' do
+      subject = article_class.new(id: 1, title: 'Awesome')
+      expect(subject.attributes).to eq(id: 1, title: 'Awesome')
+    end
+
+    it 'reflects attribute assignments' do
+      subject = article_class.new(id: 1)
+      subject.id = 42
+      expect(subject.attributes).to eq(id: 42)
+    end
+  end
+
+  describe '#attribute=' do
+    it 'assigns arbitrary attributes' do
+      subject = article_class.new
+      subject.fourty_second = 42
+
+      expect(subject.fourty_second).to be 42
+      expect(subject.attributes.keys).to include(:fourty_second)
+    end
+  end
+
+  describe '#become' do
+    subject { article_class.new(id: 1, title: 'Awesome') }
+
+    it 'copies the attributes of another element' do
+      another = article_class.new(id: 2, name: 'Superb')
+      subject.become(another)
+      expect(subject.attributes).to  eq(id: 2, name: 'Superb')
+    end
+
+    it 'raises an exception when the classes do not match' do
+      another = section_class.new(name: 'Superb')
+      expect { subject.become(another) }.to \
+        raise_error(ArgumentError, /Invalid class/i)
+    end
+  end
+end

data/spec/lib/typekit/element/persistence_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+require 'fixture/record/article'
+
+RSpec.describe Typekit::Element::Persistence do
+  let(:article_class) { Fixture::Record::Article }
+  let(:client) { double }
+
+  describe '#new?' do
+    it 'returns true for new records' do
+      subject = article_class.new
+      expect(subject).to be_new
+    end
+
+    it 'returns false for records with ids' do
+      subject = article_class.new(id: 42)
+      expect(subject).not_to be_new
+    end
+  end
+
+  describe '#persistent?' do
+    it 'returns true for persistent records' do
+      subject = article_class.new(id: 42)
+      expect(subject).to be_persistent
+    end
+
+    it 'returns false for records without ids' do
+      subject = article_class.new
+      expect(subject).not_to be_persistent
+    end
+
+    it 'returns false for deleted records' do
+      subject = article_class.new(client, id: 42)
+      allow(client).to receive(:process).and_return(true)
+
+      subject.delete
+
+      expect(subject).not_to be_persistent
+    end
+  end
+
+  describe '#save' do
+    subject { article_class.new(client) }
+
+    context 'when successful' do
+      before(:example) do
+        allow(client).to \
+          receive(:process).and_return(article_class.new(id: 42))
+      end
+
+      it 'returns true' do
+        expect(subject.save).to be true
+      end
+
+      it 'marks records as not new' do
+        expect { subject.save }.to \
+          change { subject.new? }.from(true).to(false)
+      end
+
+      it 'marks records as persistent' do
+        expect { subject.save }.to \
+          change { subject.persistent? }.from(false).to(true)
+      end
+    end
+
+    context 'when unsuccessful' do
+      before(:example) do
+        allow(client).to \
+          receive(:process).and_raise(Typekit::ServerError.new(404))
+      end
+
+      it 'returns false' do
+        expect(subject.save).to be false
+      end
+    end
+  end
+
+  describe '#delete' do
+    context 'when successful' do
+      it 'deletes and marks as deleted if not new' do
+        subject = article_class.new(client, id: 42)
+        allow(client).to receive(:process).and_return(true)
+
+        expect(subject).not_to be_deleted
+        expect(subject.delete).to be true
+        expect(subject).to be_deleted
+      end
+
+      it 'marks as deleted if new' do
+        subject = article_class.new
+
+        expect(subject).not_to be_deleted
+        expect(subject.delete).to be true
+        expect(subject).to be_deleted
+      end
+    end
+  end
+end

data/spec/lib/typekit/element/serialization_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'fixture/record/article'
+require 'fixture/record/section'
+
+RSpec.describe Typekit::Element::Serialization do
+  let(:article_class) { Fixture::Record::Article }
+  let(:section_class) { Fixture::Record::Section }
+
+  describe '#serialize' do
+    let(:attributes) do
+      {
+        id: 1,
+        title: 'Conversation',
+        sections: [{ id: 1, content: 'Hello' }, { id: 2, content: 'Bye' }]
+      }
+    end
+
+    subject do
+      object = article_class.new(attributes)
+      expect(object.sections.first).to be_kind_of(section_class)
+      object
+    end
+
+    it 'returns a Hash' do
+      expect(subject.serialize).to eq(attributes)
+    end
+  end
+end

data/spec/lib/typekit/element_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'fixture/record/article'
+
+RSpec.describe Typekit::Element do
+  include RecordHelper
+  extend RecordHelper
+
+  describe '.dictionary' do
+    it 'returns a hash whose keys are symbolic names of Record classes' do
+      expect(described_module.dictionary.keys).to \
+        include(*plural_record_symbols)
+    end
+
+    it 'returns a hash whose values are Record classes' do
+      expect(described_module.dictionary.values).to \
+        include(*record_classes)
+    end
+  end
+
+  describe '.classify' do
+    record_dictionary.each do |name, klass|
+      it "converts :#{name} into the corresponding Record class" do
+        expect(described_module.classify(name)).to eq(klass)
+      end
+
+      it "converts '#{name}' into the corresponding Record class" do
+        expect(described_module.classify(name.to_s)).to eq(klass)
+      end
+    end
+
+    plural_record_dictionary.each do |name, klass|
+      it "converts :#{name} into the corresponding Record class" do
+        expect(described_module.classify(name)).to eq(klass)
+      end
+
+      it "converts '#{name}' into the corresponding Record class" do
+        expect(described_module.classify(name.to_s)).to eq(klass)
+      end
+    end
+
+    it 'returns nil for unknown names' do
+      expect(described_module.classify('smile')).to be nil
+    end
+
+    it 'returns nil for nil' do
+      expect(described_module.classify(nil)).to be nil
+    end
+  end
+
+  describe '.build' do
+    let(:article_class) { Fixture::Record::Article }
+    subject { described_module.build(:articles) }
+
+    it 'creates an instance of an Element class' do
+      expect(subject).to be_an_instance_of(article_class)
+    end
+  end
+end

data/spec/{typekit → lib/typekit}/helper_spec.rb

@@ -1,8 +1,6 @@
 require 'spec_helper'
 
 RSpec.describe Typekit::Helper do
-  let(:subject_module) { Typekit::Helper }
-
   describe '.pluralize' do
     {
       'kit' => 'kits',
@@ -14,8 +12,8 @@ RSpec.describe Typekit::Helper do
       'variation' => 'variations',
       'variations' => 'variations'
     }.each do |k, v|
-      it "returns #{ v } for #{ k }" do
-        expect(subject_module.pluralize(k)).to eq(v)
+      it "returns #{v} for #{k}" do
+        expect(described_module.pluralize(k)).to eq(v)
       end
     end
   end
@@ -31,16 +29,16 @@ RSpec.describe Typekit::Helper do
       'variation' => 'variation',
       'variations' => 'variation'
     }.each do |k, v|
-      it "returns #{ v } for #{ k }" do
-        expect(subject_module.singularize(k)).to eq(v)
+      it "returns #{v} for #{k}" do
+        expect(described_module.singularize(k)).to eq(v)
       end
     end
   end
 
   describe '.symbolize_keys' do
     it 'does what it says' do
-      expect(subject_module.symbolize_keys('a' => { 'b' => 1 }, 'd' => 2)).to \
-        eq(a: { 'b' => 1 }, d: 2)
+      result = described_module.symbolize_keys('a' => { 'b' => 1 }, 'd' => 2)
+      expect(result).to eq(a: { 'b' => 1 }, d: 2)
     end
   end
 end

data/spec/lib/typekit/record_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'fixture/record/article'
+
+RSpec.describe Typekit::Record do
+  include RecordHelper
+  extend RecordHelper
+
+  describe '.identify' do
+    record_dictionary.each do |name, klass|
+      it "converts :#{name} into :element" do
+        expect(described_module.identify(name)).to eq(:element)
+      end
+
+      it "converts '#{name}' into :element" do
+        expect(described_module.identify(name.to_s)).to eq(:element)
+      end
+    end
+
+    plural_record_dictionary.each do |name, klass|
+      it "converts :#{name} into :collection" do
+        expect(described_module.identify(name)).to eq(:collection)
+      end
+
+      it "converts '#{name}' into :collection" do
+        expect(described_module.identify(name.to_s)).to eq(:collection)
+      end
+    end
+
+    it 'returns nil for unknown names' do
+      expect(described_module.identify('smile')).to be nil
+    end
+
+    it 'returns nil for nil' do
+      expect(described_module.identify(nil)).to be nil
+    end
+  end
+
+  describe '.build' do
+    let(:article_class) { Fixture::Record::Article }
+
+    let(:client) { double }
+    let(:element_class) { described_module.build(:articles, client) }
+
+    it 'creates a new Element class' do
+      expect(element_class < article_class).to be true
+    end
+
+    describe 'an instance of the new Element class' do
+      subject { element_class.new }
+
+      it 'makes use of the provided Client' do
+        expect(client).to receive(:process).and_return(element_class.new)
+        subject.save
+      end
+    end
+  end
+end