arkenstone-open 3.0.1

data/test/test_associations.rb

@@ -0,0 +1,327 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class AssociationsTest < Test::Unit::TestCase
+  def setup
+    @model = AssociatedUser.new
+    @model.id = 100
+    @dummy_things = [{ 'id' => 100, 'name' => 'test' }, { 'id' => 200, 'name' => 'dummy data' }]
+
+    stub_request(:get, "#{AssociatedUser.arkenstone_url}100/things").to_return do |_req|
+      { body: @dummy_things.to_json }
+    end
+
+    stub_request(:get, "#{AssociatedUser.arkenstone_url}100/roles").to_return(body: '')
+
+    @dummy_resource = { 'id' => 50, 'name' => 'Resource 1' }
+    stub_request(:get, "#{AssociatedUser.arkenstone_url}100/resource").to_return do |_req|
+      if @dummy_resource.nil?
+        { status: 200 }
+      else
+        { body: @dummy_resource.to_json }
+      end
+    end
+  end
+
+  def test_associations_dont_clobber_existing_methods
+    AssociatedUser.add_association_method 'test_method' do
+      'replaced'
+    end
+    model = AssociatedUser.new
+    assert(model.test_method == 'on AssociatedUser')
+    # model = UserWithMethods.new
+    # assert(model.things == 'on UserWithMethods')
+  end
+
+  def test_has_many_creates_child_array
+    assert(AssociatedUser.method_defined?(:things))
+    assert(@model.things.nil? == false)
+    assert(@model.things != [])
+    assert(@model.things.count == 2)
+
+    assert(@model.roles == [])
+  end
+
+  def test_has_many_creates_cached_method
+    assert(AssociatedUser.method_defined?(:cached_things))
+    assert(@model.cached_things.count == 2)
+  end
+
+  def test_has_many_creates_add_child
+    stub_request(:post, "#{AssociatedUser.arkenstone_url}100/things").to_return do |_req|
+      @dummy_things << { 'id' => 500, 'name' => 'new thing' }
+      { status: 200 }
+    end
+    assert(AssociatedUser.method_defined?(:add_thing))
+    new_thing = Thing.new
+    new_thing.name = 'new thing'
+    new_thing.id = 500
+    @model.add_thing new_thing
+    assert(@model.cached_things.count == 3)
+  end
+
+  def test_has_many_creates_remove_child
+    stub_request(:delete, "#{AssociatedUser.arkenstone_url}100/things/100").to_return do |_req|
+      @dummy_things = [{ 'id' => 200, 'name' => 'dummy data' }]
+      { status: 200 }
+    end
+
+    assert(AssociatedUser.method_defined?(:remove_thing))
+    bad_thing = Thing.new
+    bad_thing.id = 100
+    @model.remove_thing bad_thing
+    assert(@model.cached_things.count == 1)
+    assert(@model.cached_things[0].id == 200)
+  end
+
+  def test_has_one_creates_a_cached_object
+    assert(AssociatedUser.method_defined?('cached_resource'))
+    assert(!@model.cached_resource.nil?)
+  end
+
+  def test_has_one_creates_a_uncached_object
+    assert(AssociatedUser.method_defined?('resource'))
+    assert(@model.resource.id == 50)
+  end
+
+  def test_has_one_creates_a_setter
+    new_values = { id: 75, name: 'new resource' }
+    stub_request(:post, "#{AssociatedUser.arkenstone_url}100/resource").to_return(body: '')
+
+    assert(AssociatedUser.method_defined?('resource='))
+    new_resource = Resource.build new_values
+    @model.resource = new_resource
+    @dummy_resource = new_resource
+    assert(@model.resource.id == 75)
+  end
+
+  def test_has_one_can_delete_an_association
+    stub_request(:delete, "#{AssociatedUser.arkenstone_url}100/resource/50").to_return(status: 200)
+    @model.resource = nil
+    @dummy_resource = nil
+    assert(@model.resource.nil?)
+  end
+
+  def test_associations_uses_the_same_namespace
+    eval %(
+      module Foo
+        class Bar
+          include Arkenstone::Document
+        end
+
+        class MyClass
+          include Arkenstone::Document
+          url "http://example.com/myclasses/"
+
+          attributes :id, :name
+
+          has_many :bars
+        end
+      end
+    )
+    stub_request(:get, "#{Foo::MyClass.arkenstone_url}100/bars").to_return(body: '')
+    model = Foo::MyClass.new
+    model.id = 100
+    result = model.bars
+    assert(!result.nil?)
+  end
+
+  def test_assoications_handles_405
+    eval %(
+      module Foo
+        class Bar
+          include Arkenstone::Document
+        end
+
+        class MyClass
+          include Arkenstone::Document
+          url "http://example.com/myclasses/"
+
+          attributes :id, :name
+
+          has_one :bar
+        end
+      end
+    )
+    stub_request(:get, "#{Foo::MyClass.arkenstone_url}100/bar").to_return(status: '405', body: 'ERROR')
+    model = Foo::MyClass.new
+    model.id = 100
+    result = model.bar
+    assert(result == [])
+  end
+
+  def test_belongs_to_association
+    eval %(
+      module Foo
+        class Bar
+          include Arkenstone::Document
+          url 'http://example.com/bar'
+
+          attributes :id
+          belongs_to :freezer
+        end
+
+        class Freezer
+          include Arkenstone::Document
+          url 'http://example.com/freezer'
+
+          attributes :id, :age
+          has_many :bars
+        end
+      end
+    )
+
+    stub_request(:post, "#{Foo::Freezer.arkenstone_url}/").to_return(status: '200', body: { id: 1 }.to_json)
+    stub_request(:post, "#{Foo::Bar.arkenstone_url}/").to_return(status: '200', body: { id: 1, freezer_id: 1 }.to_json)
+
+    freezer = Foo::Freezer.create({ age: 30 })
+    bar     = Foo::Bar.create({ freezer: })
+
+    stub_request(:get, "#{Foo::Freezer.arkenstone_url}/1").to_return(status: 200, body: freezer.to_json)
+
+    assert_equal(freezer.id, bar.freezer_id)
+    assert_equal(freezer.to_json, bar.freezer.to_json)
+    assert_equal(bar.cached_freezer.id, freezer.id)
+  end
+
+  def test_has_and_belongs_to_many
+    # Pending Test
+
+    return true
+    eval %(
+       module Foo
+         class Bar
+           include Arkenstone::Document
+           url 'http://example.com/bar'
+
+           attributes :id
+           has_and_belongs_to_many :freezers
+         end
+
+         class Freezer
+           include Arkenstone::Document
+           url 'http://example.com/freezer'
+
+           attributes :id, :age
+           has_and_belongs_to_many :bars
+         end
+       end
+     )
+
+    stub_request(:post, "#{Foo::Freezer.arkenstone_url}/").to_return(status: '200',
+                                                                     body: {
+                                                                       id: 1, bar_ids: []
+                                                                     }.to_json)
+    stub_request(:post, "#{Foo::Bar.arkenstone_url}/").to_return(status: '200',
+                                                                 body: {
+                                                                   id: 1, freezer_ids: [1]
+                                                                 }.to_json)
+
+    freezer = Foo::Freezer.create({ age: 30 })
+    bar     = Foo::Bar.create({ freezers: [freezer] })
+
+    stub_request(:get, "#{Foo::Freezer.arkenstone_url}/1").to_return(status: 200,
+                                                                     body: freezer.merge({ bar_ids: [bar.id] }).to_json)
+    stub_request(:get, "#{Foo::Bar.arkenstone_url}/1").to_return(status: 200,
+                                                                 body: bar.merge({ freezer_ids: [freezer.id] }).to_json)
+
+    assert(bar.freezer_ids.include?(freezer.id))
+    assert(freezer.bar_ids.include?(bar.id))
+
+    freezer = Foo::Freezer.find(1)
+    bar     = Foo::Bar.find(1)
+
+    assert_equal(1, freezer.bars.length)
+    assert_equal(1, bar.freezers.length)
+
+    found_freezer = bar.freezers.first
+    found_bar     = freezer.bars.first
+
+    assert_equal(freezer.to_json, found_freezer.to_json)
+    assert_equal(bar.to_json, found_bar.to_json)
+  end
+
+  def test_handles_nested_json
+    eval %(
+      module Foo
+        class Bar
+          include Arkenstone::Document
+          url 'http://example.com/bar'
+
+          attributes :id
+          belongs_to :freezer
+        end
+
+        class Freezer
+          include Arkenstone::Document
+          url 'http://example.com/freezer'
+
+          attributes :id, :age
+          has_many :bars
+        end
+      end
+    )
+
+    stub_request(:post, "#{Foo::Freezer.arkenstone_url}/").to_return(status: '200', body: { id: 1 }.to_json)
+    stub_request(:post, "#{Foo::Bar.arkenstone_url}/").to_return(status: '200', body: { id: 1, freezer_id: 1 }.to_json)
+
+    freezer = Foo::Freezer.create({ age: 30 })
+    bar     = Foo::Bar.create({ freezer: })
+
+    stub_request(:get, "#{Foo::Freezer.arkenstone_url}/1").to_return(status: 200,
+                                                                     body: {
+                                                                       id: 1, age: 30, bars: [{ id: 1 }]
+                                                                     }.to_json)
+    stub_request(:get, "#{Foo::Freezer.arkenstone_url}/1/bars").to_return(status: 200, body: [{ id: 1 }].to_json)
+
+    freezer = Foo::Freezer.find(freezer.id)
+
+    assert(freezer.bars)
+    assert(freezer.bar_ids)
+    assert(freezer.bar_ids.include?(bar.id))
+  end
+
+  def test_allows_custom_url
+    eval %(
+      class Tool
+        include Arkenstone::Document
+        attributes :name
+        url 'http://example.com/tools'
+      end
+
+      class Garage
+        include Arkenstone::Document
+        attributes :address
+        url 'http://example.com/garages'
+
+        has_many :tools, model_name: 'derps'
+      end
+    )
+    stub_request(:get,
+                 "#{Garage.arkenstone_url}/10/derps").to_return(body: [{ name: 'test' }, { name: 'other' }].to_json)
+    g = Garage.new
+    g.id = 10
+    tools = g.tools
+    assert_equal(2, tools.count)
+  end
+
+  def test_has_many_custom_class
+    eval %(
+      class Organization
+        include Arkenstone::Document
+        attributes :name
+        url 'http://example.com/organizations'
+
+        has_many :child_organizations, class_name: :organization, model_name: 'descendents'
+      end
+    )
+    url = "#{Organization.arkenstone_url}/10/descendents"
+    children = [{ name: 'child 1' }, { name: 'child 2' }]
+    stub_request(:get, url).to_return(body: children.to_json)
+    parent = Organization.new
+    parent.id = 10
+    child_orgs = parent.child_organizations
+    assert_equal(2, child_orgs.count)
+  end
+end

data/test/test_enumerables.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class EnumerableTests < Test::Unit::TestCase
+  def test_json_returns_attributes_of_elements
+    eval %(
+      class EnumerableElement
+        include Arkenstone::Document
+
+        attributes :name, :id
+      end
+    )
+    dummy = EnumerableElement.new
+    dummy.name = 'test'
+    dummy.id = 100
+
+    dummy2 = EnumerableElement.new
+    dummy2.name = 'test2'
+    dummy2.id = 101
+
+    list = Arkenstone::QueryList.new [dummy, dummy2]
+    result = list.to_json
+    assert_equal(result, '[{"name":"test","id":100},{"name":"test2","id":101}]')
+  end
+
+  def test_initialize_takes_array
+    list = Arkenstone::QueryList.new [10, 20]
+    assert_equal([10, 20], list)
+  end
+
+  def test_initialize_takes_element
+    list = Arkenstone::QueryList.new 'test'
+    assert_equal ['test'], list
+  end
+end

data/test/test_environment.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class ArkenstoneEnvTest < Test::Unit::TestCase
+  def setup
+    @env = Arkenstone::Environment.new url: 'http://example.com', verb: :get
+  end
+
+  def test_env_takes_hash_to_init
+    assert(@env.url == 'http://example.com')
+    assert(@env.verb == :get)
+  end
+end

data/test/test_helpers.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class HelpersTest < Test::Unit::TestCase
+  def test_full_url
+    eval %(
+      class FooTest
+        include Arkenstone::Document
+        include Arkenstone::Helpers
+
+        url 'http://example.com'
+      end
+    )
+
+    assert_equal('http://example.com/', FooTest.full_url(FooTest.arkenstone_url))
+  end
+end

data/test/test_hooks.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class RequestHook < Arkenstone::Hook
+  attr_accessor :called
+
+  def before_request(_req)
+    @called = true
+  end
+end
+
+class ResponseHook < Arkenstone::Hook
+  attr_accessor :called
+
+  def after_complete(_resp)
+    @called = true
+  end
+end
+
+class ArkenstoneHookTest < Test::Unit::TestCase
+  def test_hook_called_before_request
+    request_hook = RequestHook.new
+    User.add_hook request_hook
+    assert(User.arkenstone_hooks.count == 1)
+    stub_request(:get, "#{User.arkenstone_url}1").to_return(body: '{}')
+    User.find(1)
+    assert(request_hook.called, 'hook was not called')
+  end
+
+  def test_hook_called_after_complete
+    resp_hook = ResponseHook.new
+    User.add_hook resp_hook
+    stub_request(:get, "#{User.arkenstone_url}1").to_return(body: '{}')
+    User.find(1)
+    assert(resp_hook.called, 'response hook was not called')
+  end
+
+  def test_has_hooks
+    eval %(
+      class BaseThing
+        include Arkenstone::Document
+        add_hook RequestHook.new
+      end
+    )
+    assert_equal(true, Arkenstone::Hook.has_hooks?(BaseThing))
+  end
+
+  def test_has_hooks_via_inheritance
+    eval %(
+      class BaseThing
+        include Arkenstone::Document
+        add_hook RequestHook.new
+      end
+
+      class ChildThing < BaseThing
+        inherit_hooks
+      end
+
+    )
+    assert_equal(true, Arkenstone::Hook.has_hooks?(ChildThing))
+  end
+
+  def test_has_hooks_negative
+    eval %(
+      class NoHooks
+      end
+    )
+    assert_equal(false, Arkenstone::Hook.has_hooks?(NoHooks))
+  end
+
+  def test_all_hooks_for_class_verifies_inherit_hooks
+    eval %(
+      class BaseThing
+        include Arkenstone::Document
+        add_hook ResponseHook.new
+      end
+
+      class ChildThing < BaseThing
+        add_hook RequestHook.new
+      end
+    )
+    assert_equal(1, Arkenstone::Hook.all_hooks_for_class(ChildThing).count)
+  end
+
+  def test_all_hooks_for_class_walks_the_inheritance_chain
+    eval %(
+      class BaseBaseThing
+        include Arkenstone::Document
+        add_hook ResponseHook.new
+      end
+
+      class DerpChildThing < BaseBaseThing
+        add_hook RequestHook.new
+        inherit_hooks
+      end
+    )
+    assert_equal(2, Arkenstone::Hook.all_hooks_for_class(DerpChildThing).count)
+  end
+
+  def teardown
+    User.arkenstone_hooks = []
+  end
+end

data/test/test_query_builder.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class QueryBuilderTest < Test::Unit::TestCase
+  def setup
+    @builder = Arkenstone::QueryBuilder.new
+  end
+
+  def test_build_find_with_one_param
+    json = @builder.build do
+      {
+        foo: 'foo'
+      }
+    end
+
+    assert_equal '{"foo":"foo"}', json
+  end
+
+  def test_build_find_in
+    json = @builder.build do
+      {
+        foo: _in(%w[foo bar])
+      }
+    end
+    assert_equal '{"foo":{"$in":["foo","bar"]}}', json
+  end
+
+  def test_query_find_comparison
+    json = @builder.build do
+      {
+        foo: _gt(500)
+      }
+    end
+    assert_equal '{"foo":{"$gt":500}}', json
+  end
+
+  def test_query_complex_find
+    json = @builder.build do
+      {
+        foo: 'foo',
+        bar: _in(%w[foo bar]),
+        baz: _gt(400)
+      }
+    end
+    assert_equal '{"foo":"foo","bar":{"$in":["foo","bar"]},"baz":{"$gt":400}}', json
+  end
+
+  def test_query_and
+    json = @builder.build do
+      _and(
+        { foo: 'foo' },
+        { bar: 'bar' }
+      )
+    end
+    assert_equal '{"$and":[{"foo":"foo"},{"bar":"bar"}]}', json
+  end
+
+  def test_query_and_with_gt
+    json = @builder.build do
+      _and(
+        { foo: _gt(200) },
+        { foo: _lt(300) }
+      )
+    end
+    assert_equal '{"$and":[{"foo":{"$gt":200}},{"foo":{"$lt":300}}]}', json
+  end
+
+  def test_include
+    json = @builder.build do
+      _include %w[Foo Bar]
+      {
+        foo: 'foo'
+      }
+    end
+    assert_equal '{"$include":["Foo","Bar"],"foo":"foo"}', json
+  end
+
+  def test_limit
+    json = @builder.build do
+      _limit 5
+      {
+        foo: 'foo'
+      }
+    end
+    assert_equal '{"$limit":5,"foo":"foo"}', json
+  end
+
+  def test_complex_include_with_booleans
+    json = @builder.build do
+      _include %w[DocDataElement Document]
+      _or(
+        _and(
+          { 'DocDataElement.Name' => 'AccountNumber' },
+          { 'Value' => '123456' }
+        ),
+        _and(
+          { 'DocDataElement.Name' => 'Zip' },
+          { 'Value' => '55555' }
+        )
+      )
+    end
+    assert_equal '{"$include":["DocDataElement","Document"],"$or":[{"$and":[{"DocDataElement.Name":"AccountNumber"},{"Value":"123456"}]},{"$and":[{"DocDataElement.Name":"Zip"},{"Value":"55555"}]}]}',
+                 json
+  end
+
+  def test_query_not
+    json = @builder.build do
+      _or(
+        _and(
+          { foo: _gt(200) },
+          { bar: 'bar' }
+        ),
+        _not(
+          { baz: 'derp' }
+        )
+      )
+    end
+    assert_equal '{"$or":[{"$and":[{"foo":{"$gt":200}},{"bar":"bar"}]},{"$not":[{"baz":"derp"}]}]}', json
+  end
+
+  def test_query_or
+    json = @builder.build do
+      _or(
+        { foo: _gt(200) },
+        { bar: 'bar' }
+      )
+    end
+    assert_equal '{"$or":[{"foo":{"$gt":200}},{"bar":"bar"}]}', json
+  end
+
+  def test_query_complex_and
+    json = @builder.build do
+      _or(
+        _and(
+          { foo: _gt(200) },
+          { bar: 'bar' }
+        ),
+        _and(
+          { derp: 'derp' }
+        )
+      )
+    end
+    assert_equal '{"$or":[{"$and":[{"foo":{"$gt":200}},{"bar":"bar"}]},{"$and":[{"derp":"derp"}]}]}', json
+  end
+
+  def test_query_is_idempotent
+    json = @builder.build do
+      _and(
+        { foo: _gt(200) },
+        { bar: 'bar' }
+      )
+    end
+    assert_equal '{"$and":[{"foo":{"$gt":200}},{"bar":"bar"}]}', json
+    json = @builder.build do
+      _and(
+        { foo: _gt(200) },
+        { derp: 'derp derp' }
+      )
+    end
+    assert_equal '{"$and":[{"foo":{"$gt":200}},{"derp":"derp derp"}]}', json
+  end
+end