lurch 0.1.0

data/test/lurch/test_delete_resources.rb

@@ -0,0 +1,27 @@
+require_relative "../test_helper"
+
+class TestDeleteResources < Minitest::Test
+  include LurchTest
+
+  def test_delete_existing_resource_from_server_using_store
+    stub_get("#{person_type}/1", @response_factory.person_response("1", "Alice"))
+    delete_stub = stub_delete("#{person_type}/1", @response_factory.no_content_response)
+
+    person = @store.from(:people).find("1")
+    response = @store.delete(person)
+
+    assert_requested delete_stub
+    assert response
+  end
+
+  def test_delete_existing_resource_from_server_using_query
+    stub_get("#{person_type}/1", @response_factory.person_response("1", "Alice"))
+    delete_stub = stub_delete("#{person_type}/1", @response_factory.no_content_response)
+
+    person = @store.from(:people).find("1")
+    response = @store.from(:people).delete(person)
+
+    assert_requested delete_stub
+    assert response
+  end
+end

data/test/lurch/test_errors.rb

@@ -0,0 +1,29 @@
+require_relative "../test_helper"
+
+class TestErrors < Minitest::Test
+  include LurchTest
+
+  def test_401
+    stub_get("#{person_type}/1", @response_factory.unauthorized_response)
+    err = assert_raises(Lurch::Errors::Unauthorized) { @store.from(:people).find("1") }
+    assert_equal "401: Unauthorized", err.message
+  end
+
+  def test_403
+    stub_get("#{person_type}/1", @response_factory.forbidden_response)
+    err = assert_raises(Lurch::Errors::Forbidden) { @store.from(:people).find("1") }
+    assert_equal "403: Forbidden", err.message
+  end
+
+  def test_404
+    stub_get("#{person_type}/999", @response_factory.not_found_response)
+    err = assert_raises(Lurch::Errors::NotFound) { @store.from(:people).find("999") }
+    assert_equal "404: Not Found", err.message
+  end
+
+  def test_500
+    stub_get("#{person_type}/1", @response_factory.server_error_response)
+    err = assert_raises(Lurch::Errors::ServerError) { @store.from(:people).find("1") }
+    assert_equal "500: Internal Server Error", err.message
+  end
+end

data/test/lurch/test_fetch_relationships.rb

@@ -0,0 +1,50 @@
+require_relative "../test_helper"
+
+class TestFetchRelationships < Minitest::Test
+  include LurchTest
+
+  def test_fetch_linked_has_one_relationship_from_server
+    stub_get("#{phone_number_type}/1", @response_factory.phone_number_response("1", "Cell", "111-222-3344"))
+    stub_get("#{phone_number_type}/1/contact", @response_factory.person_response("1", "Alice"))
+
+    phone_number = @store.from(:phone_numbers).find("1")
+
+    assert_kind_of Lurch::Relationship::Linked, phone_number.contact
+    assert phone_number.contact.inspect
+    assert_raises(Lurch::Errors::RelationshipNotLoaded) { phone_number.contact.name }
+    err = assert_raises(Lurch::Errors::RelationshipNotLoaded) { phone_number.contact.respond_to?(:name) }
+    assert_equal "Relationship (contact) not loaded, try calling #fetch first.", err.message
+
+    phone_number.contact.fetch
+    person = phone_number.contact
+
+    assert_kind_of Lurch::Resource, person
+    assert_kind_of Lurch::Relationship::Linked, phone_number.relationships[:contact]
+    assert_raises(NoMethodError) { phone_number.relationships[:contact].name }
+    refute phone_number.relationships[:contact].respond_to?(:name)
+    assert_equal "Alice", person.name
+  end
+
+  def test_fetch_linked_has_many_relationship_from_server
+    stub_get("#{person_type}/1", @response_factory.person_response("1", "Alice"))
+    stub_get(
+      "#{person_type}/1/#{@inflector.encode_key(:phone_numbers)}",
+      @response_factory.phone_numbers_response(["1", "Cell", "111-222-3344"], ["2", "Home", "222-111-3344"])
+    )
+
+    person = @store.from(:people).find("1")
+
+    assert_kind_of Lurch::Relationship::Linked, person.phone_numbers
+    assert_equal false, person.phone_numbers.loaded?
+    assert person.phone_numbers.inspect
+
+    person.phone_numbers.fetch
+    phone_numbers = person.phone_numbers
+
+    assert_kind_of Lurch::Collection, phone_numbers
+    assert_equal true, person.phone_numbers.loaded?
+    assert_kind_of Lurch::Relationship::Linked, person.relationships[:phone_numbers]
+    assert_equal 2, phone_numbers.size
+    assert_equal "Cell", phone_numbers.first.name
+  end
+end

data/test/lurch/test_fetch_resources.rb

@@ -0,0 +1,77 @@
+require_relative "../test_helper"
+
+class TestFetchResources < Minitest::Test
+  include LurchTest
+
+  def test_fetch_resource_from_server
+    stub_get("#{person_type}/1", @response_factory.person_response("1", "Alice"))
+
+    person = @store.from(:people).find("1")
+
+    assert_equal "Alice", person.name
+    assert person.inspect
+  end
+
+  def test_fetch_resource_collection_from_server
+    stub_get(person_type, @response_factory.people_response(["1", "Alice"], ["2", "Bob"]))
+
+    people = @store.from(:people).all
+
+    assert_kind_of Lurch::Collection, people
+    assert_equal 2, people.size
+    assert_equal ["Alice", "Bob"], people.map(&:name)
+    assert people.inspect
+  end
+
+  def test_fetch_already_fetched_resource_from_store
+    stub = stub_get("#{person_type}/1", @response_factory.person_response("1", "Alice"))
+
+    @store.from(:people).find("1")
+
+    remove_request_stub(stub)
+
+    assert @store.from(:people).find("1")
+  end
+
+  def test_fetch_resource_from_server_that_includes_has_one_relationship
+    stub_get("#{phone_number_type}/1", @response_factory.phone_number_response("1", "Cell", "111-222-3344", ["1", "Alice"]))
+
+    phone_number = @store.from(:phone_numbers).find("1")
+
+    assert_kind_of Lurch::Relationship::HasOne, phone_number.relationships[:contact]
+    assert phone_number.relationships[:contact].inspect
+    assert_kind_of Lurch::Resource, phone_number.contact
+    assert_equal "Alice", phone_number.contact.name
+  end
+
+  def test_fetch_resource_from_server_that_includes_has_many_relationship
+    stub_get("#{person_type}/1", @response_factory.person_response("1", "Alice", [["1", "Cell", "1112223344"], ["2", "Home", "2221113344"]]))
+
+    person = @store.from(:people).find("1")
+
+    assert_kind_of Lurch::Relationship::HasMany, person.relationships[:phone_numbers]
+    assert person.relationships[:phone_numbers].inspect
+    assert_kind_of Array, person.phone_numbers
+    assert_equal "Cell", person.phone_numbers.first.name
+  end
+
+  def test_fetch_resource_that_includes_resource_identifiers_only
+    stub_get("#{person_type}/1", @response_factory.person_response("1", "Alice", [["1"]], include_phone_numbers: false))
+
+    person = @store.from(:people).find("1")
+    phone_number = person.phone_numbers.first
+
+    assert_equal "1", phone_number.id
+    refute phone_number.loaded?
+    assert phone_number.inspect
+    err = assert_raises(Lurch::Errors::ResourceNotLoaded) { phone_number.name }
+    assert_equal "Resource (PhoneNumber) not loaded, try calling #fetch first.", err.message
+
+    stub_get("#{phone_number_type}/1", @response_factory.phone_number_response("1", "Cell", "111-222-3344"))
+
+    phone_number.fetch
+
+    assert phone_number.loaded?
+    assert_equal "Cell", phone_number.name
+  end
+end

data/test/lurch/test_inflector.rb

@@ -0,0 +1,13 @@
+require_relative "../test_helper"
+
+class TestInflector < Minitest::Test
+  include LurchTest
+
+  def test_bad_inflector
+    err = assert_raises(ArgumentError) { Lurch::Inflector.new(:foo, :pluralize) }
+    assert_equal "Invalid inflection mode: foo", err.message
+
+    err = assert_raises(ArgumentError) { Lurch::Inflector.new(:dasherize, :bar) }
+    assert_equal "Invalid types mode: bar", err.message
+  end
+end

data/test/lurch/test_paginated_collections.rb

@@ -0,0 +1,125 @@
+require_relative "../test_helper"
+
+class TestPaginatedCollections < Minitest::Test
+  include LurchTest
+
+  def test_fetch_paginated_resource_collection_from_server
+    stub_get(person_type, @response_factory.paginated_people_response(10, 1, 2))
+
+    people = @store.from(:people).all
+
+    assert_kind_of Lurch::Collection, people
+    assert_equal 20, people.size
+    assert_equal 10, people.page_size
+    assert_equal 2, people.page_count
+  end
+
+  def test_fetch_next_page_of_paginated_resource_collection_from_server
+    stub_get(person_type, @response_factory.paginated_people_response(10, 1, 2))
+
+    people = @store.from(:people).all
+
+    assert people.next?
+
+    page2_stub = stub_get("#{person_type}?page[number]=2&page[size]=10", @response_factory.paginated_people_response(10, 2, 2))
+
+    people.next_collection
+
+    assert_requested page2_stub
+  end
+
+  def test_fetch_previous_page_of_paginated_resource_collection_from_server
+    stub_get("#{person_type}?page[number]=2&page[size]=10", @response_factory.paginated_people_response(10, 2, 2))
+
+    people = @store.from(:people).page(number: 2, size: 10).all
+
+    assert people.prev?
+
+    page1_stub = stub_get("#{person_type}?page[number]=1&page[size]=10", @response_factory.paginated_people_response(10, 1, 2))
+
+    people.prev_collection
+
+    assert_requested page1_stub
+  end
+
+  def test_fetch_first_page_of_paginated_resource_collection_from_server
+    stub_get("#{person_type}?page[number]=2&page[size]=10", @response_factory.paginated_people_response(10, 2, 2))
+
+    people = @store.from(:people).page(number: 2, size: 10).all
+
+    assert people.first?
+
+    page1_stub = stub_get("#{person_type}?page[number]=1&page[size]=10", @response_factory.paginated_people_response(10, 1, 2))
+
+    people.first_collection
+
+    assert_requested page1_stub
+  end
+
+  def test_fetch_last_page_of_paginated_resource_collection_from_server
+    stub_get(person_type, @response_factory.paginated_people_response(10, 1, 2))
+
+    people = @store.from(:people).all
+
+    assert people.last?
+
+    page2_stub = stub_get("#{person_type}?page[number]=2&page[size]=10", @response_factory.paginated_people_response(10, 2, 2))
+
+    people.last_collection
+
+    assert_requested page2_stub
+  end
+
+  def test_enumerate_paginated_collection_by_resource
+    page1_stub = stub_get(person_type, @response_factory.paginated_people_response(10, 1, 3))
+    page2_stub = stub_get("#{person_type}?page[number]=2&page[size]=10", @response_factory.paginated_people_response(10, 2, 3))
+    page3_stub = stub_get("#{person_type}?page[number]=3&page[size]=10", @response_factory.paginated_people_response(10, 3, 3))
+
+    people = @store.from(:people).all
+    names = people.map(&:name)
+
+    assert_kind_of Array, names
+    assert names.size == 30
+    assert names.first == "Person1"
+    assert names.last == "Person30"
+
+    assert_requested page1_stub
+    assert_requested page2_stub
+    assert_requested page3_stub
+  end
+
+  def test_enumerate_paginated_collection_by_page
+    page1_stub = stub_get(person_type, @response_factory.paginated_people_response(10, 1, 3))
+    page2_stub = stub_get("#{person_type}?page[number]=2&page[size]=10", @response_factory.paginated_people_response(10, 2, 3))
+    page3_stub = stub_get("#{person_type}?page[number]=3&page[size]=10", @response_factory.paginated_people_response(10, 3, 3))
+
+    people = @store.from(:people).all
+
+    people.each_page do |page|
+      assert_kind_of Array, page
+      assert page.size == 10
+    end
+
+    assert_requested page1_stub
+    assert_requested page2_stub
+    assert_requested page3_stub
+  end
+
+  def test_lazy_enumeration
+    page1_stub = stub_get(person_type, @response_factory.paginated_people_response(10, 1, 3))
+    page2_stub = stub_get("#{person_type}?page[number]=2&page[size]=10", @response_factory.paginated_people_response(10, 2, 3))
+    page3_stub = stub_get("#{person_type}?page[number]=3&page[size]=10", @response_factory.paginated_people_response(10, 3, 3))
+
+    people = @store.from(:people).all
+    names = people.lazy.map(&:name).first(20)
+
+    assert_kind_of Array, names
+    assert names.size == 20
+    assert names.first == "Person1"
+    assert names.last == "Person20"
+
+    assert_requested page1_stub
+    assert_requested page2_stub
+    assert_not_requested page3_stub
+  end
+end

data/test/lurch/test_queries.rb

@@ -0,0 +1,104 @@
+require_relative "../test_helper"
+
+class TestQueries < Minitest::Test
+  include LurchTest
+
+  def test_filter
+    stub = stub_get(
+      "#{person_type}?filter[name]=Alice&filter[foo][]=bar&filter[foo][]=baz",
+      @response_factory.no_content_response
+    )
+
+    @store
+      .from(:people)
+      .filter(name: "Alice", foo: ["bar", "baz"])
+      .all
+
+    assert_requested(stub)
+  end
+
+  def test_include
+    stub = stub_get(
+      "#{person_type}?include=#{@inflector.encode_key(:phone_numbers)},friends,friends.#{@inflector.encode_key(:phone_numbers)}",
+      @response_factory.no_content_response
+    )
+
+    @store
+      .from(:people)
+      .include(:phone_numbers, :friends, "friends.phone_numbers")
+      .all
+
+    assert_requested(stub)
+  end
+
+  def test_fields
+    stub = stub_get(
+      "#{person_type}?fields[#{person_type}]=name&fields[#{phone_number_type}]=name,number",
+      @response_factory.no_content_response
+    )
+
+    @store
+      .from(:people)
+      .fields([:name])
+      .fields(:phone_number, [:name, :number])
+      .all
+
+    assert_requested(stub)
+  end
+
+  def test_sort
+    stub = stub_get(
+      "#{person_type}?sort=name,-foo,bar",
+      @response_factory.no_content_response
+    )
+
+    @store
+      .from(:people)
+      .sort(:name, {foo: :desc}, {bar: :asc})
+      .all
+
+    assert_requested(stub)
+  end
+
+  def test_bad_sort
+    assert_raises ArgumentError do
+      @store.from(:people).sort(foo: :bar).all
+    end
+  end
+
+  def test_page
+    stub = stub_get(
+      "#{person_type}?page[number]=12&page[size]=50",
+      @response_factory.no_content_response
+    )
+
+    @store
+      .from(:people)
+      .page(number: 12, size: 50)
+      .all
+
+    assert_requested(stub)
+  end
+
+  def test_all
+    stub = stub_get(
+      "#{person_type}?filter[name]=Alice&filter[foo][]=bar&filter[foo][]=baz&include=#{@inflector.encode_key(:phone_numbers)},friends,friends.#{@inflector.encode_key(:phone_numbers)}&fields[#{person_type}]=name&fields[#{phone_number_type}]=name,number&sort=name,-foo,bar&page[number]=12&page[size]=50",
+      @response_factory.no_content_response
+    )
+
+    query = @store
+      .from(:people)
+      .filter(name: "Alice", foo: ["bar", "baz"])
+      .include(:phone_numbers, :friends, "friends.phone_numbers")
+      .fields([:name])
+      .fields(:phone_number, [:name, :number])
+      .sort(:name, {foo: :desc}, {bar: :asc})
+      .page(number: 12, size: 50)
+
+    assert query.inspect
+
+    query.all
+
+    assert_requested(stub)
+  end
+end

data/test/lurch/test_relationship.rb

@@ -0,0 +1,17 @@
+require_relative "../test_helper"
+
+class TestRelationship < Minitest::Test
+  include LurchTest
+
+  def test_bad_relationship_document
+    err = assert_raises(ArgumentError) { Lurch::Relationship.from_document(nil, nil, {}) }
+    assert_equal "Invalid relationship document", err.message
+  end
+
+  def test_nil_has_one_relationship
+    rel = Lurch::Relationship::HasOne.new(nil, nil, {data: nil})
+
+    assert rel.loaded?
+    assert_nil rel.data
+  end
+end

data/test/lurch/test_resource.rb

@@ -0,0 +1,34 @@
+require_relative "../test_helper"
+
+class TestResource < Minitest::Test
+  include LurchTest
+
+  def test_resource_equality
+    stub_get("#{person_type}/1", @response_factory.person_response("1", "Alice"))
+    stub_get("#{person_type}/2", @response_factory.person_response("2", "Bob"))
+
+    person1 = @store.from(:people).find("1")
+    person1_again = @store.from(:people).find("1")
+    person2 = @store.from(:people).find("2")
+
+    assert person1 == person1_again
+    assert person1.eql? person1_again
+    refute person1.equal? person1_again
+    refute person1 == person2
+    refute person1.eql? person2
+    refute person1.equal? person2
+  end
+
+  def test_resource_attribute_getters
+    stub_get("#{person_type}/1", @response_factory.person_response("1", "Alice"))
+
+    person = @store.from(:people).find("1")
+
+    assert person.name == "Alice"
+    assert person[:name] == "Alice"
+    assert person.respond_to?(:name)
+
+    refute person.respond_to?(:foo)
+    assert_raises(NoMethodError) { person.foo }
+  end
+end

data/test/lurch/test_update_relationships.rb

@@ -0,0 +1,53 @@
+require_relative "../test_helper"
+
+class TestUpdateRelationships < Minitest::Test
+  include LurchTest
+
+  def test_add_resources_to_has_many_relationship
+    stub_get("#{person_type}/1", @response_factory.person_response("1", "Alice"))
+    stub_get("#{phone_number_type}/1", @response_factory.phone_number_response("1", "Cell", "111-222-3344"))
+    stub_post("#{person_type}/1/relationships/#{@inflector.encode_key(:phone_numbers)}", @response_factory.no_content_response)
+
+    person = @store.from(:people).find("1")
+    phone_number = @store.from(:phone_numbers).find("1")
+    response = @store.add_related(person, :phone_numbers, [phone_number])
+
+    assert_requested :post, "#{@url}/#{person_type}/1/relationships/#{@inflector.encode_key(:phone_numbers)}", body: "{\"data\":[{\"id\":\"1\",\"type\":\"#{phone_number_type}\"}]}"
+    assert response
+  end
+
+  def test_remove_resources_from_has_many_relationship
+    stub_get("#{person_type}/1", @response_factory.person_response("1", "Alice"))
+    stub_get("#{person_type}/1/#{@inflector.encode_key(:phone_numbers)}", @response_factory.phone_numbers_response(["1", "Cell", "111-222-3344"]))
+    stub_delete("#{person_type}/1/relationships/#{@inflector.encode_key(:phone_numbers)}", @response_factory.no_content_response)
+
+    person = @store.from(:people).find("1")
+    phone_number = person.phone_numbers.fetch.first
+    response = @store.remove_related(person, :phone_numbers, [phone_number])
+
+    assert_requested :delete, "#{@url}/#{person_type}/1/relationships/#{@inflector.encode_key(:phone_numbers)}", body: "{\"data\":[{\"id\":\"1\",\"type\":\"#{phone_number_type}\"}]}"
+    assert response
+  end
+
+  def test_replace_resources_for_has_many_relationship
+    stub_get("#{person_type}/1", @response_factory.person_response("1", "Alice"))
+    stub_patch("#{person_type}/1/relationships/#{@inflector.encode_key(:phone_numbers)}", @response_factory.no_content_response)
+
+    person = @store.from(:people).find("1")
+    response = @store.update_related(person, :phone_numbers, [])
+
+    assert_requested :patch, "#{@url}/#{person_type}/1/relationships/#{@inflector.encode_key(:phone_numbers)}", body: '{"data":[]}'
+    assert response
+  end
+
+  def test_replace_resource_for_has_one_relationship
+    stub_get("#{phone_number_type}/1", @response_factory.phone_number_response("1", "Cell", "111-222-3344"))
+    stub_patch("#{phone_number_type}/1/relationships/contact", @response_factory.no_content_response)
+
+    phone_number = @store.from(:phone_numbers).find("1")
+    response = @store.update_related(phone_number, :contact, nil)
+
+    assert_requested :patch, "#{@url}/#{phone_number_type}/1/relationships/contact", body: '{"data":null}'
+    assert response
+  end
+end

data/test/lurch/test_update_resources.rb

@@ -0,0 +1,56 @@
+require_relative "../test_helper"
+
+class TestUpdateResources < Minitest::Test
+  include LurchTest
+
+  def test_update_existing_resource_on_server_using_store
+    stub_get("#{person_type}/2", @response_factory.person_response("2", "Bob"))
+    stub_patch("#{person_type}/2", @response_factory.person_response("2", "Robert"))
+
+    person = @store.from(:people).find("2")
+
+    assert_equal "Bob", person.name
+
+    changeset = Lurch::Changeset.new(person, name: "Robert")
+    @store.save(changeset)
+
+    assert changeset.inspect
+    assert_requested :patch, "#{@url}/#{person_type}/2", body: "{\"data\":{\"id\":\"2\",\"type\":\"#{person_type}\",\"attributes\":{\"name\":\"Robert\"}}}"
+    assert_equal "Robert", person.name
+  end
+
+  def test_update_existing_resource_on_server_using_query
+    stub_get("#{person_type}/2", @response_factory.person_response("2", "Bob"))
+    stub_patch("#{person_type}/2", @response_factory.person_response("2", "Robert"))
+
+    person = @store.from(:people).find("2")
+
+    assert_equal "Bob", person.name
+
+    changeset = Lurch::Changeset.new(person)
+    changeset.set(:name, "Robert")
+    @store.to(:people).save(changeset)
+
+    assert_requested :patch, "#{@url}/#{person_type}/2", body: "{\"data\":{\"id\":\"2\",\"type\":\"#{person_type}\",\"attributes\":{\"name\":\"Robert\"}}}"
+    assert_equal "Robert", person.name
+  end
+
+  def test_validation_errors_when_updating_existing_resource
+    stub_get("#{person_type}/2", @response_factory.person_response("2", "Bob"))
+    stub_patch("#{person_type}/2", @response_factory.unprocessable_entity_response("name - can't be blank"))
+
+    person = @store.from(:people).find("2")
+
+    assert_equal "Bob", person.name
+
+    changeset = Lurch::Changeset.new(person, name: "")
+
+    err = assert_raises(Lurch::Errors::UnprocessableEntity) { @store.save(changeset) }
+    assert_equal "422: name - can't be blank", err.message
+    assert_equal 422, changeset.errors.first.status
+    assert_equal "name - can't be blank", changeset.errors.first.detail
+
+    assert_requested :patch, "#{@url}/#{person_type}/2", body: "{\"data\":{\"id\":\"2\",\"type\":\"#{person_type}\",\"attributes\":{\"name\":\"\"}}}"
+    assert_equal "Bob", person.name
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,15 @@
+require "pry"
+require "simplecov"
+require "codecov"
+require "webmock/minitest"
+
+require_relative "helpers/lurch_test"
+require_relative "helpers/response_factory"
+
+SimpleCov.formatter = SimpleCov::Formatter::Codecov
+SimpleCov.start do
+  add_filter "/test/"
+end
+
+require "minitest/autorun"
+require "lurch"