arkenstone-open 3.0.1

data/test/associations/test_has_and_belongs_to_many.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class HasAndBelongsToManyTest < Test::Unit::TestCase
+  def test_has_and_belongs_to_many
+    eval %(
+      module BrewMaster
+        class Tag
+          include Arkenstone::Document
+          include Arkenstone::Queryable
+          url 'http://example.com/tag'
+
+          attributes :id, :name
+          has_and_belongs_to_many :beers
+        end
+
+        class Beer
+          include Arkenstone::Document
+          include Arkenstone::Queryable
+          url 'http://example.com/beer'
+
+          attributes :id, :brand, :filtered
+          has_and_belongs_to_many :tags
+        end
+      end
+    )
+
+    assert(BrewMaster::BeerTag)
+    %w[beer beer= beer_id beer_id= cached_beer tag tag= tag_id tag_id= cached_tag].each do |injected_method|
+      assert(BrewMaster::BeerTag.new.respond_to?(injected_method.to_sym))
+    end
+
+    assert(BrewMaster::Tag.new.respond_to?(:beer_tags))
+    assert(BrewMaster::Beer.new.respond_to?(:beer_tags))
+
+    stub_request(:post, "#{BrewMaster::Tag.arkenstone_url}/").to_return(status: '200', body: { id: 1 }.to_json)
+    stub_request(:post, "#{BrewMaster::Beer.arkenstone_url}/").to_return(status: '200', body: { id: 1 }.to_json)
+
+    %w[blonde pale ipa hot sour].each do |tag|
+      BrewMaster::Tag.create(name: tag)
+    end
+
+    beer = BrewMaster::Beer.create(brand: 'Full Sail', filtered: false)
+
+    stub_request(:post,
+                 "#{BrewMaster::Tag.arkenstone_url}/query").with(body: { name: 'ipa' }.to_json).to_return(body: [{ id: 1,
+                                                                                                                   name: 'ipa' }].to_json)
+
+    tag = BrewMaster::Tag.where(name: 'ipa').first
+
+    stub_request(:get, "#{BrewMaster::Tag.arkenstone_url}/1/beer_tags").to_return(status: 200, body: [].to_json)
+    stub_request(:get, "#{BrewMaster::Beer.arkenstone_url}/1/beer_tags").to_return(status: 200, body: [].to_json)
+
+    assert(beer.respond_to?(:tags))
+    assert(tag.respond_to?(:beers))
+
+    assert(beer.tags.empty?)
+    assert(tag.beers.empty?)
+
+    beer.tags << tag
+    assert(beer.tags.include?(tag))
+    assert(tag.beers.include?(beer))
+
+    stub_request(:put, "#{BrewMaster::Tag.arkenstone_url}/1").to_return(status: '200', body: { id: 1 }.to_json)
+    stub_request(:put, "#{BrewMaster::Beer.arkenstone_url}/1").to_return(status: '200', body: { id: 1 }.to_json)
+
+    beer.save
+    tag.save
+
+    stub_request(:get, "#{BrewMaster::Tag.arkenstone_url}/1").to_return(status: 200, body: { id: 1 }.to_json)
+    stub_request(:get, "#{BrewMaster::Beer.arkenstone_url}/1").to_return(status: 200, body: { id: 1 }.to_json)
+
+    beer.reload
+    tag.reload
+
+    assert(beer.tags.include?(tag))
+    assert(tag.beers.include?(beer))
+  end
+end

data/test/dummy/app/models/association.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'user'
+
+class Thing
+  include Arkenstone::Document
+  include Arkenstone::Timestamps
+
+  url 'http://example.com/things'
+  attributes :id, :name
+end
+
+class Role
+  include Arkenstone::Document
+  include Arkenstone::Timestamps
+  attributes :id, :name
+end
+
+class Resource
+  include Arkenstone::Document
+  include Arkenstone::Timestamps
+  attributes :id, :name
+end
+
+class AssociatedUser < User
+  url 'http://example.com/associated_users/'
+
+  has_many :things
+  has_many :roles
+  has_one :resource
+
+  def test_method
+    'on AssociatedUser'
+  end
+end

data/test/dummy/app/models/superuser.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'user'
+
+class SuperUser < User
+  url 'http://example.com/superusers'
+  attributes :group_name
+end

data/test/dummy/app/models/user.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class User
+  include Arkenstone::Document
+  include Arkenstone::Timestamps
+  include Arkenstone::Queryable
+
+  url 'http://example.com/users/'
+  attributes :name, :age, :gender, :bearded
+end

data/test/spec_helper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'webmock/test_unit'
+
+# Add in some pry debuggin niceties
+require 'pry'
+require 'pry-nav'
+
+# Include code coverage
+require 'simplecov'
+SimpleCov.start
+
+# Make a simple document for test cases.
+require_relative '../lib/arkenstone'
+Dir['./test/dummy/app/models/**/*.rb'].each { |f| require f }

data/test/test_arkenstone.rb

@@ -0,0 +1,354 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class DummyRequest
+  attr_accessor :body
+end
+
+class ArkenstoneTest < Test::Unit::TestCase
+  def test_arkenstone_url_set
+    eval %(
+      class ArkenstoneUrlTest
+        include Arkenstone::Document
+        url 'http://example.com'
+      end
+    )
+
+    assert(ArkenstoneUrlTest)
+    assert(ArkenstoneUrlTest.arkenstone_url == 'http://example.com')
+  end
+
+  def test_arkenstone_attributes_set
+    eval %(
+      class ArkenstoneAttributesTest
+        include Arkenstone::Document
+        attributes :name, :age
+      end
+    )
+    arkenstone = ArkenstoneAttributesTest.new
+
+    assert(ArkenstoneAttributesTest.arkenstone_attributes == %i[name age])
+    assert(arkenstone.respond_to?(:name))
+    assert(arkenstone.respond_to?(:age))
+  end
+
+  def test_new_record
+    user = User.build user_options
+    assert_equal true, user.new_record?
+    user.id = 100
+    assert_equal false, user.new_record?
+  end
+
+  def test_builds_from_params
+    user = User.build(user_options)
+    assert(user.instance_of?(User), 'user class was not User')
+    assert(user.age == 18, "user's age was not 18")
+  end
+
+  def tests_builds_from_nil_params
+    user = User.build(nil)
+    assert(user.instance_of?(User), 'user class was not User')
+  end
+
+  def test_returns_json
+    user = User.build(user_options)
+    json = user.to_json
+    assert(json, 'user#to_json method does not exist')
+    parsed = JSON.parse json
+    assert(parsed['name'] == user.name)
+  end
+
+  def test_to_json_accepts_options
+    # This case was added to give backwards compatibility to rails render_json
+    user = User.build(user_options)
+    assert(user.to_json, 'user#to_json fails without options')
+    assert(user.to_json(key: 'value'), 'user#to_json fails with options')
+  end
+
+  def test_attribute_changes_updates_json
+    user = User.build(user_options)
+    old_json = user.to_json
+    user.bearded = false
+    assert(user.to_json != old_json)
+    assert(user.to_json == user_options.merge(bearded: false).to_json)
+  end
+
+  def test_finds_instance_by_id
+    user_json = user_options.merge({ id: 1 }).to_json
+    stub_request(:get, "#{User.arkenstone_url}1").to_return(body: user_json)
+    user = User.find(1)
+    assert user
+    assert user.id == 1
+  end
+
+  def test_instance_not_found_is_nil
+    stub_request(:any, "#{User.arkenstone_url}1").to_return(body: '', status: 404)
+    user = User.find 1
+    assert_nil user
+  end
+
+  def test_finds_all_instances
+    users_json = [
+      user_options.merge({ id: 1 }),
+      user_options.merge({ id: 2 })
+    ].to_json
+
+    stub_request(:get, User.arkenstone_url).to_return(body: users_json)
+    users = User.all
+    assert(users.length == 2)
+    assert((users.select { |user| user.id == 1 }).length == 1)
+    assert((users.select { |user| user.id == 2 }).length == 1)
+  end
+
+  def test_save_new_record
+    user = User.build user_options
+    assert(!user.id, 'user has an id')
+
+    stub_request(:post, User.arkenstone_url).to_return(body: user_options.merge({ id: 1 }).to_json)
+    assert_equal(true, user.save)
+    assert(user.id == 1, 'user does not have an id')
+  end
+
+  def test_save_is_false_for_server_error
+    user = User.build user_options
+    stub_request(:post, User.arkenstone_url).to_return(body: { message: 'oh no' }.to_json, status: 500)
+    assert_equal(false, user.save)
+  end
+
+  def test_dont_set_readonly_attribute
+    eval %(
+      class ReadOnlyAttrs
+        include Arkenstone::Document
+        attributes :name
+
+        def readonly
+          'oh hi'
+        end
+      end
+    )
+    obj = ReadOnlyAttrs.new
+    vals = { name: 'my name', readonly: 'uh oh' }
+    obj.attributes = vals
+    assert_equal('oh hi', obj.readonly)
+  end
+
+  def test_save_current_record
+    user = User.build user_options.merge({ id: 1, bearded: false })
+    assert(user.bearded != true)
+
+    stub_request(:put,
+                 "#{User.arkenstone_url}#{user.id}").to_return(body: user_options.merge({ id: 1,
+                                                                                          bearded: true }).to_json)
+    user.bearded = true
+    user.save
+
+    assert(user.bearded == true)
+
+    stub_request(:get,
+                 "#{User.arkenstone_url}#{user.id}").to_return(body: user_options.merge({ id: 1,
+                                                                                          bearded: true }).to_json)
+    user = User.find(user.id)
+    assert(user.bearded == true)
+  end
+
+  def test_save_throws_an_error_for_no_url
+    eval %(
+      class NoUrlModel
+        include Arkenstone::Document
+        attributes :name
+      end
+    )
+    model = NoUrlModel.new
+    model.name = 'No Save'
+    assert_raise NoUrlError do
+      model.save
+    end
+  end
+
+  def test_creates
+    stub_request(:post, User.arkenstone_url).to_return(body: user_options.merge({ id: 1 }).to_json)
+
+    user = User.create(user_options)
+    assert(user.age == 18, "user's age was not 18")
+    assert(user.id == 1, "user doesn't have an id")
+    assert(user.created_at, 'created_at is nil')
+    assert(user.updated_at, 'updated_at is nil')
+  end
+
+  def test_destroys
+    user = build_user 1
+    stub_request(:delete, "#{User.arkenstone_url}#{user.id}").to_return(status: 200)
+    result = user.destroy
+    assert(result == true, 'delete was not true')
+  end
+
+  def test_update_attributes
+    stub_request(:post, User.arkenstone_url).to_return(body: user_options.merge({ id: 1 }).to_json)
+
+    user = User.create(user_options)
+
+    stub_request(:put,
+                 "#{User.arkenstone_url}#{user.id}").to_return(body: user_options.merge({ id: 1, name: 'Jack Doe',
+                                                                                          age: 24 }).to_json)
+
+    result = user.update_attributes({ name: 'Jack Doe', age: 24 })
+    assert(result != false)
+    assert(user.name == 'Jack Doe', 'user#name is not eq Jack Doe')
+    assert(user.age == 24, 'user#age is not eq 24')
+  end
+
+  def test_set_request_data_uses_json
+    user = build_user 1
+    request = Net::HTTP::Post.new 'http://localhost'
+    Arkenstone::Network.set_request_data request, user.attributes
+    assert(request.content_type == 'application/json')
+    assert(request.body == '{"name":"John Doe","age":18,"gender":"Male","bearded":true}')
+  end
+
+  def test_set_request_data_double_json
+    request = Net::HTTP::Post.new 'http://localhost'
+    Arkenstone::Network.set_request_data request, { name: 'test' }.to_json
+    assert(request.body == '{"name":"test"}')
+  end
+
+  def test_set_request_headers_sets_headers
+    request = Net::HTTP::Post.new 'http://localhost'
+    headers = { 'Test' => 'foo', 'Other' => 'other' }
+    Arkenstone::Network.set_request_headers request, headers
+    assert(request['Test'] == 'foo')
+    assert(request['Other'] == 'other')
+  end
+
+  def test_update_attribute
+    stub_request(:post, User.arkenstone_url).to_return(body: user_options.merge({ id: 1 }).to_json)
+
+    user = User.create(user_options)
+
+    stub_request(:put,
+                 "#{User.arkenstone_url}#{user.id}").to_return(body: user_options.merge({ id: 1,
+                                                                                          name: 'Jack Doe' }).to_json)
+
+    user.update_attribute 'name', 'Jack Doe'
+    assert(user.name == 'Jack Doe', 'Jack doe is not alive')
+
+    stub_request(:put,
+                 "#{User.arkenstone_url}#{user.id}").to_return(body: user_options.merge({ id: 1,
+                                                                                          name: 'Jacked Doe' }).to_json)
+    user.update_attribute :name, 'Jacked Doe'
+    assert(user.name == 'Jacked Doe', 'Jack is not Jacked')
+  end
+
+  def test_inheritance
+    su = SuperUser.build({ group_name: 'some group' })
+    assert(su.attributes == { group_name: 'some group' })
+    assert(SuperUser.arkenstone_url == 'http://example.com/superusers')
+  end
+
+  def test_save_attributes
+    eval %(
+      class ArkenstoneAttrHook < Arkenstone::Hook
+        attr_accessor :called
+        def encode_attributes(attrs)
+          @called = true
+          attrs
+        end
+      end
+    )
+    hook = ArkenstoneAttrHook.new
+    User.add_hook hook
+    u = User.new
+    u.saveable_attributes
+    assert_equal(true, hook.called)
+  end
+
+  def test_parse_all_builds_array
+    json = '[{ "id": 100, "name": "test" }, { "id": 200, "name": "built" }]'
+    result = User.parse_all json
+    assert(result.count == 2)
+  end
+
+  def test_parse_all_handles_object
+    obj = [{ id: 100, name: 'test' }, { id: 200, name: 'built' }]
+    result = User.parse_all obj
+    assert(result.count == 2)
+  end
+
+  def test_parse_all_treats_single_object_as_array
+    obj = { id: 100, name: 'test' }
+    result = User.parse_all obj.to_json
+    assert_equal(1, result.count)
+    assert_equal('test', result.first.name)
+  end
+
+  def test_parse_all_catches_empty_json
+    result = User.parse_all ''
+    assert(result == [])
+  end
+
+  def test_handle_error_in_save
+    eval %(
+      class Rock
+        include Arkenstone::Document
+
+        url 'http://example.com/rocks'
+        attributes :name
+      end
+    )
+    stub_request(:post, "#{Rock.arkenstone_url}/").to_return(status: 500, body: { error: 'derp' }.to_json)
+    rock = Rock.create(name: 'err')
+    assert_equal(false, rock.arkenstone_server_errors.nil?)
+  end
+
+  def test_dup
+    u = User.build user_options
+    u.id = 1337
+    dup_u = u.dup
+    dup_u.attributes.each { |key, value| assert_equal value, u.attributes[key] }
+    assert_equal nil, dup_u.id
+  end
+
+  def test_reload
+    eval %(
+      class Ball
+        include Arkenstone::Document
+
+        url 'http://example.com/balls'
+        attributes :color
+      end
+    )
+
+    stub_request(:post, "#{Ball.arkenstone_url}/").to_return(status: '200', body: { id: 1, color: 'blue' }.to_json)
+
+    ball = Ball.create(color: 'blue')
+    assert(ball.color == 'blue')
+
+    ball.color = 'orange'
+    assert(ball.color == 'orange')
+
+    stub_request(:put, "#{Ball.arkenstone_url}/1").to_return(status: '200', body: { id: 1, color: 'orange' }.to_json)
+
+    ball.save
+
+    stub_request(:get, "#{Ball.arkenstone_url}/1").to_return(status: 200, body: { id: 1, color: 'orange' }.to_json)
+
+    ball.reload
+    assert(ball.color == 'orange')
+
+    found_ball = Ball.find(ball.id)
+    assert(found_ball.color == 'orange')
+  end
+end
+
+def build_user(id)
+  User.build user_options.merge({ id: })
+end
+
+def create_user(options, id)
+  stub_request(:post, User.arkenstone_url).to_return(body: options.merge({ id: }).to_json)
+  User.build(options).save
+end
+
+def user_options(options = {})
+  { name: 'John Doe', age: 18, gender: 'Male', bearded: true }.merge!(options)
+end

data/test/test_arkenstone_hook_inheritance.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class TestHook < Arkenstone::Hook
+  attr_accessor :called
+
+  def before_request(_req)
+    @called = true
+  end
+end
+
+class ArkenstoneHookInheritanceTest < Test::Unit::TestCase
+  def test_hooks_do_inheritance
+    eval %(
+      class BaseModel
+        include Arkenstone::Document
+      end
+
+      class ChildModel < BaseModel
+        inherit_hooks
+      end
+    )
+    hook = TestHook.new
+    BaseModel.add_hook hook
+    Arkenstone::Hook.call_request_hooks ChildModel, nil
+    assert(hook.called)
+  end
+
+  def test_inherit_hooks
+    eval %(
+      class ArkenstoneHookAttr
+        include Arkenstone::Document
+        inherit_hooks
+      end
+    )
+    assert(ArkenstoneHookAttr.arkenstone_inherit_hooks)
+  end
+end