jsonapi-consumer 0.1.0.pre.1

data/spec/jsonapi/consumer/associations_spec.rb

@@ -0,0 +1,141 @@
+RSpec.describe 'Associations', 'has_many' do
+  let(:user_class) do
+    User ||= Class.new do
+      include JSONAPI::Consumer::Resource
+
+      has_many :posts, class_name: 'Post'
+    end
+  end
+
+  let!(:post_class) do
+    Post ||= Class.new do
+      include JSONAPI::Consumer::Resource
+    end
+  end
+
+  subject(:user_instance) { user_class.new(username: 'foobar') }
+
+  it 'lists association names in #association_names' do
+    expect(user_instance.association_names).to eql([:posts])
+  end
+
+  describe 'defined accessors for assocation' do
+    it { is_expected.to respond_to(:posts) }
+    it { is_expected.to respond_to(:posts=) }
+  end
+
+  describe 'adding objects to array' do
+    it 'can be added as a single value' do
+      expect {
+        user_instance.posts = '1'
+      }.to change{user_instance.post_ids}.from(nil).to(['1'])
+    end
+
+    it 'can be added as a list of items' do
+      expect {
+        user_instance.posts = ['1','2','3']
+      }.to change{user_instance.post_ids}.from(nil).to(['1','2','3'])
+    end
+
+    it 'can be blanked out' do
+      user_instance.posts = '1'
+      expect {
+        user_instance.posts = nil
+      }.to change{user_instance.post_ids}.from(['1']).to(nil)
+    end
+  end
+
+  describe 'the links payload' do
+    subject(:payload_hash) { user_instance.serializable_hash }
+
+    it 'has links in output' do
+      expect(payload_hash).to have_key(:links)
+    end
+  end
+end
+
+RSpec.describe 'Associations', 'belongs_to' do
+  let(:comment_class) do
+    Comment ||= Class.new do
+      include JSONAPI::Consumer::Resource
+
+      # belongs_to :comment, class_name: 'Comment'
+      belongs_to :user, class_name: 'User'
+    end
+  end
+
+  let!(:user_class) do
+    User ||= Class.new do
+      include JSONAPI::Consumer::Resource
+    end
+  end
+
+  subject(:comment_instance) { comment_class.new }
+
+  it 'lists association names in #association_names' do
+    expect(comment_instance.association_names).to eql([:user])
+  end
+
+  describe 'defined accessors for assocation' do
+    it { is_expected.to respond_to(:user) }
+    it { is_expected.to respond_to(:user=) }
+  end
+
+  describe 'adding objects to belongs_to relationship' do
+    it 'can be added as a single value' do
+      expect {
+        comment_instance.user = '1'
+      }.to change{comment_instance.user_id}.from(nil).to('1')
+    end
+
+    it 'can be blanked out' do
+      comment_instance.user = '1'
+      expect {
+        comment_instance.user = nil
+      }.to change{comment_instance.user_id}.from('1').to(nil)
+    end
+  end
+end
+
+RSpec.describe 'Associations', 'has_one' do
+  let(:post_class) do
+    Poster ||= Class.new do
+      include JSONAPI::Consumer::Resource
+
+      has_one :author, class_name: 'Customer'
+    end
+  end
+
+  let!(:user_class) do
+    Customer ||= Class.new do
+      include JSONAPI::Consumer::Resource
+    end
+  end
+
+  subject(:post_instance) { post_class.new }
+
+  it 'lists association names in #association_names' do
+    expect(post_instance.association_names).to eql([:author])
+  end
+
+  describe 'defined accessors for assocation' do
+    it { is_expected.to respond_to(:author) }
+    it { is_expected.to respond_to(:author=) }
+  end
+
+  describe 'adding objects to belongs_to relationship' do
+    it 'can be added as a single value' do
+      expect {
+        post_instance.author = '1'
+      }.to change{post_instance.author_id}.from(nil).to('1')
+    end
+
+    it 'can be blanked out' do
+      post_instance.author = '1'
+      expect {
+        post_instance.author = nil
+      }.to change{post_instance.author_id}.from('1').to(nil)
+    end
+  end
+end
+

data/spec/jsonapi/consumer/attributes_spec.rb

@@ -0,0 +1,27 @@
+RSpec.describe 'Attributes' do
+  let(:test_class) do
+    Class.new do
+      include JSONAPI::Consumer::Resource
+    end
+  end
+
+  subject(:obj) { test_class.new }
+
+  its(:primary_key) { is_expected.to eql(:id) }
+
+  describe 'changing the primary key' do
+    it 'is updatable on the class' do
+      expect {
+        obj.class.primary_key = :name
+      }.to change{obj.primary_key}.to(:name)
+    end
+  end
+
+  describe '#persisted?' do
+    it 'uses the primary key to decide' do
+      expect {
+        obj.id = '8'
+      }.to change{obj.persisted?}.from(false).to(true)
+    end
+  end
+end

data/spec/jsonapi/consumer/connection_spec.rb

@@ -0,0 +1,101 @@
+RSpec.describe 'Connection' do
+  let(:test_class) do
+    Record ||= Class.new do
+      include JSONAPI::Consumer::Resource
+      self.host = 'http://localhost:3000/api/'
+
+      has_one :domain
+    end
+  end
+
+  let(:obj) { test_class.new(name: 'jsonapi.example') }
+
+  describe '.all' do
+    it 'returns all results as objects' do
+      stub_request(:get, "http://localhost:3000/api/records")
+        .to_return(headers: {content_type: "application/json"}, body: {
+          records: [
+            {id: '1', name: "foo.example"},
+            {id: '2', name: "bar.example"},
+            {id: '3', name: "baz.example"}
+          ]
+        }.to_json)
+
+      records = test_class.all
+      expect(records.size).to eql(3)
+
+      record = records.first
+      expect(record).to be_a(Record)
+    end
+  end
+
+  describe '.find' do
+    it 'returns proper objects' do
+      stub_request(:get, "http://localhost:3000/api/records/1")
+        .to_return(headers: {content_type: "application/json"}, body: {
+          records: [
+            {id: '1', name: "foobar.example"}
+          ]
+        }.to_json)
+
+      records = test_class.find(1)
+      expect(records.size).to eql(1)
+
+      record = records.first
+      expect(record).to be_a(Record)
+      expect(record.id).to eql('1')
+      expect(record.name).to eql('foobar.example')
+    end
+  end
+
+  describe '#save' do
+    it 'can save successfully if called on a new item' do
+      stub_request(:post, "http://localhost:3000/api/records")
+        .to_return(headers: {content_type: "application/json"}, status: 201, body: {
+          records: [
+            {id: '1', name: "foobar.example", created_at: "2014-10-16T18:49:40Z", updated_at: "2014-10-18T18:59:40Z"}
+          ]
+        }.to_json)
+
+      expect(obj.save).to eql(true)
+
+      expect(obj.id).to eql('1')
+      expect(obj.name).to eql('foobar.example')
+
+      expect(obj.created_at).to eql('2014-10-16T18:49:40Z')
+      expect(obj.updated_at).to eql('2014-10-18T18:59:40Z')
+
+      expect(obj).to respond_to(:created_at)
+      expect(obj).to respond_to(:updated_at)
+      expect(obj.persisted?).to eql(true)
+    end
+
+    it 'can update when called on an existing item' do
+      stub_request(:put, "http://localhost:3000/api/records/1")
+        .to_return(headers: {content_type: "application/json"}, body: {
+          records: [
+            {id: '1', name: "foobar.example", created_at: "2014-10-16T18:49:40Z", updated_at: "2016-10-18T18:59:40Z"}
+          ]
+        }.to_json)
+
+      obj.id = '1'
+      obj.updated_at = "2014-10-18T18:59:40Z"
+      expect(obj.updated_at).to eql("2014-10-18T18:59:40Z")
+
+      expect(obj.save).to eql(true)
+      expect(obj.updated_at).to eql("2016-10-18T18:59:40Z")
+    end
+  end
+
+  describe '#destroy' do
+    before { obj.id = '1' }
+
+    it 'returns true when successful' do
+      stub_request(:delete, "http://localhost:3000/api/records/1")
+        .to_return(status: 204, body: nil)
+
+      expect(obj.destroy).to eql(true)
+    end
+  end
+end
+

data/spec/jsonapi/consumer/error_handling_spec.rb

@@ -0,0 +1,37 @@
+RSpec.describe 'Error handling' do
+  let(:test_class) do
+    Record ||= Class.new do
+      include JSONAPI::Consumer::Resource
+      self.host = 'http://localhost:3000/api/'
+
+      has_one :domain
+    end
+  end
+
+  let(:obj) { test_class.new(name: 'jsonapi.example') }
+
+  context 'on model' do
+    it 'adds to the errors object on the model' do
+      stub_request(:post, "http://localhost:3000/api/records")
+        .to_return(headers: {content_type: "application/json"}, status: 400, body: {
+          errors: [
+            {title: 'cannot be blank', path: "/name", detail: 'name cannot be blank'},
+            {title: 'is invalid', path: '/type', detail: 'type is invalid'}
+          ]
+        }.to_json)
+
+      expect(obj.save).to eql(false)
+      expect(obj.is_valid?).to eql(false)
+    end
+  end
+
+  context 'in general' do
+    it 'handles timeout errors' do
+      stub_request(:any, "http://localhost:3000/api/records").to_timeout
+
+      expect {
+        obj.save
+      }.to raise_error(JSONAPI::Consumer::Errors::ServerNotResponding)
+    end
+  end
+end

data/spec/jsonapi/consumer/object_build_spec.rb

@@ -0,0 +1,20 @@
+RSpec.describe 'Object building' do
+  let(:class_name) { BuildRequest }
+
+  subject(:obj) { class_name.build }
+
+  it 'returns an object with populated items' do
+    stub_request(:get, "http://localhost:3000/api/build_requests/new")
+      .to_return(headers: {content_type: "application/json"}, body: {
+          build_requests: [
+            {name: "", title: "default value"}
+          ]
+        }.to_json)
+
+    expect(obj).to respond_to(:name)
+    expect(obj).to respond_to(:title)
+
+    expect(obj.name).to be_blank
+    expect(obj.title).to eql("default value")
+  end
+end

data/spec/jsonapi/consumer/parser_spec.rb

@@ -0,0 +1,41 @@
+RSpec.describe 'Response Parsing' do
+  let(:response) { OpenStruct.new(body: Responses.sideload) }
+  let(:parser) { JSONAPI::Consumer::Parser.new(Blog::Post, response) }
+
+  subject(:results) { parser.build }
+
+  it 'can handle linked associations' do
+    stub_request(:get, 'http://localhost:3000/api/comments/9c9ba83b-024c-4d4c-9573-9fd41b95fc14')
+      .to_return(headers: {content_type: "application/json"}, body: {
+          comments: [
+            {
+              id: '9c9ba83b-024c-4d4c-9573-9fd41b95fc14',
+              content: "i found this useful."
+            }
+          ]
+        }.to_json)
+
+    stub_request(:get, 'http://localhost:3000/api/comments/27fcf6e8-24b0-41db-94b1-812046a10f54')
+      .to_return(headers: {content_type: "application/json"}, body: {
+          comments: [
+            {
+              id: '27fcf6e8-24b0-41db-94b1-812046a10f54',
+              content: "i found this useful too."
+            }
+          ]
+        }.to_json)
+
+    # puts results.inspect
+    expect(results.size).to eql(2)
+
+    result = results.first
+    expect(result.comments.size).to eql(2)
+
+    last = results.last
+    expect(result.comments.size).to eql(2)
+
+    expect(last.comments.first).to be_a(Blog::Comment)
+    expect(last.comments.first.id).to eql("9c9ba83b-024c-4d4c-9573-9fd41b95fc14")
+    expect(last.comments.first.content).to eql("i found this useful.")
+  end
+end

data/spec/jsonapi/consumer/resource_spec.rb

@@ -0,0 +1,62 @@
+RSpec.describe 'Resource' do
+  let(:sample_attrs) {
+    {
+      id: SecureRandom.uuid,
+      name: 'foo',
+      content: 'bar'
+    }
+  }
+
+  subject(:test_class) do
+    Paper ||= Class.new do
+      include JSONAPI::Consumer::Resource
+    end
+  end
+
+  it 'it errors on undefined methods' do
+    obj = test_class.new
+    expect {
+      obj.paper
+    }.to raise_error(NoMethodError)
+  end
+
+  describe 'accepts any passed in params through #attributes=' do
+    subject(:instance) { test_class.new }
+
+    before do
+      instance.attributes = sample_attrs
+    end
+
+    it { is_expected.to respond_to(:id) }
+    it { is_expected.to respond_to(:name) }
+    it { is_expected.to respond_to(:content) }
+  end
+
+  describe 'accepts attributes through .new' do
+    subject(:instance) { test_class.new(sample_attrs) }
+
+    it { is_expected.to respond_to(:id) }
+    it { is_expected.to respond_to(:name) }
+    it { is_expected.to respond_to(:content) }
+  end
+
+  describe '#serializable_hash' do
+    subject(:obj_hash) { test_class.new(sample_attrs).serializable_hash }
+
+    it 'has proper keys' do
+      expect(obj_hash).to have_key(:id)
+      expect(obj_hash).to have_key(:name)
+      expect(obj_hash).to have_key(:content)
+    end
+  end
+
+  describe '#to_json' do
+    subject(:obj_hash) { test_class.new(sample_attrs).to_json }
+
+    it 'has all attributes root key' do
+      json_hash = JSON.parse(obj_hash)
+      expect(json_hash.keys).to eql(['id', 'name', 'content'])
+    end
+  end
+
+end

data/spec/jsonapi/consumer/serializer_spec.rb

@@ -0,0 +1,41 @@
+RSpec.describe 'Serializer' do
+  let(:test_class) do
+    SerializerTestClass ||= Class.new do
+      include JSONAPI::Consumer::Resource
+
+      has_many :users, class_name: 'Account'
+      has_one :owner, class_name: 'Owner'
+    end
+  end
+
+  let(:owner) {
+    Owner ||= Class.new do
+      include JSONAPI::Consumer::Resource
+
+      def to_param
+        1
+      end
+    end
+  }
+
+  let(:user) {
+    Account ||= Class.new do
+      include JSONAPI::Consumer::Resource
+    end
+  }
+
+  subject(:obj_hash) { test_class.new(id: '76', owner: owner.new, users: [user.new(id: 'a'), user.new(id: 'b')]).serializable_hash }
+
+  it 'outputs the associated has_one' do
+    expect(obj_hash).to have_key(:links)
+    expect(obj_hash[:links]).to have_key(:owner)
+    expect(obj_hash[:links][:owner]).to eql(1)
+  end
+
+  it 'outputs the associated has_many' do
+    expect(obj_hash).to have_key(:links)
+    expect(obj_hash[:links]).to have_key(:users)
+    expect(obj_hash[:links][:users]).to eql(['a', 'b'])
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,97 @@
+require 'jsonapi/consumer'
+
+require 'rspec/its'
+require 'webmock/rspec'
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/spec/support/load_fixtures.rb

@@ -0,0 +1,4 @@
+require File.expand_path('../../fixtures/resources', __FILE__)
+require File.expand_path('../../fixtures/responses', __FILE__)
+
+Responses.sideload