chassis 0.1.0

data/test/rack/no_robots_test.rb

@@ -0,0 +1,34 @@
+require_relative '../test_helper'
+
+class NoRobotsTest < MiniTest::Unit::TestCase
+  include Rack::Test::Methods
+
+  class HelloWorld
+    def call(env)
+      [200, {'Content-Type' => 'text/plain' }, 'Hi']
+    end
+  end
+
+  attr_reader :log, :app
+
+  def setup
+    @log = StringIO.new
+    builder = Rack::Builder.new
+    builder.use Chassis::Rack::NoRobots
+    builder.run HelloWorld.new
+    @app = builder.to_app
+  end
+
+  def test_does_not_allow_any_robots
+    get '/robots.txt'
+
+    assert_includes last_response.body, 'Disallow: /'
+    assert_includes last_response.body, 'User Agent: *'
+  end
+
+  def test_allows_other_requests
+    get '/foo'
+
+    assert_equal 'Hi', last_response.body
+  end
+end

data/test/registry_test.rb

@@ -0,0 +1,26 @@
+require_relative 'test_helper'
+
+class RegistryTest < MiniTest::Unit::TestCase
+  def test_can_get_and_set_values
+    registry = Chassis::Registry.new
+    registry[:foo] = 'bar'
+    assert_equal registry.fetch(:foo), 'bar'
+  end
+
+  def test_fails_with_an_error_if_nothing_registred
+    registry = Chassis::Registry.new
+    assert_raises Chassis::UnregisteredError do
+      registry.fetch :foo
+    end
+  end
+
+  def test_can_be_cleared
+    registry = Chassis::Registry.new
+    registry[:foo] = 'bar'
+    assert_equal registry.fetch(:foo), 'bar'
+    registry.clear
+    assert_raises Chassis::UnregisteredError do
+      registry.fetch :foo
+    end
+  end
+end

data/test/repo/delegation_test.rb

@@ -0,0 +1,101 @@
+require_relative '../test_helper'
+
+class RepoDelegationTest < MiniTest::Unit::TestCase
+  class PersonRepo
+    extend Chassis::Repo::Delegation
+
+    def self.obj_class
+      Person
+    end
+  end
+
+  class SomethingSomething
+    extend Chassis::Repo::Delegation
+  end
+
+  Person = Struct.new :name
+
+  attr_reader :target, :person
+
+  def repo
+    PersonRepo
+  end
+
+  def setup
+    @target = mock
+    @person = Person.new 'ahawkins'
+    Chassis::Repo.stubs(:default).returns(target)
+  end
+
+  def test_classes_that_dont_match_on_name_fail_with_a_helpful_error
+    assert_raises Chassis::UnknownObjectClassError do
+      SomethingSomething.object_class
+    end
+  end
+
+  def test_find_delegates_to_the_target
+    target.expects(:find).with(Person, 1)
+    repo.find(1)
+  end
+
+  def test_delete_delegates_to_the_target
+    target.expects(:delete).with(person)
+    repo.delete(person)
+  end
+
+  def test_save_delegates_to_the_target
+    target.expects(:save).with(person)
+    repo.save(person)
+  end
+
+  def test_first_delegates_to_the_target
+    target.expects(:first).with(Person)
+    repo.first
+  end
+
+  def test_last_delegates_to_the_target
+    target.expects(:last).with(Person)
+    repo.last
+  end
+
+  def test_all_delegates_to_the_target
+    target.expects(:all).with(Person)
+    repo.all
+  end
+
+  def test_count_delegates_to_the_target
+    target.expects(:count).with(Person)
+    repo.count
+  end
+
+  def test_query_delegates_to_the_target
+    target.expects(:query).with(Person, :foo)
+    repo.query :foo
+  end
+
+  def test_query_bang__delegates_to_the_target
+    target.expects(:query!).with(Person, :foo)
+    repo.query! :foo
+  end
+
+  def test_graph_query_delegates_to_the_target
+    target.expects(:graph_query).with(Person, :foo)
+    repo.graph_query(:foo)
+  end
+
+  def test_sample_delegates_to_the_backend
+    target.expects(:sample).with(Person)
+    repo.sample
+  end
+
+  def test_empty_delegates_to_the_backend
+    target.expects(:empty?).with(Person)
+    repo.empty?
+  end
+
+  def test_lazy_returns_new_lazy_associations
+    target.expects(:find).never
+    person = repo.lazy 'ahawkins'
+    assert_equal 'ahawkins', person.id
+  end
+end

data/test/repo/lazy_association_test.rb

@@ -0,0 +1,115 @@
+require_relative '../test_helper'
+
+class LazyAssociationTest < MiniTest::Unit::TestCase
+  class Person
+    attr_reader :id, :name
+
+    def initialize(id, name = nil)
+      @id, @name = id, name
+    end
+
+    def ==(other)
+      other.instance_of?(self.class) && other.id == id
+    end
+  end
+
+  class PersonRepo
+    class << self
+      def object_class
+        Person
+      end
+    end
+  end
+
+  attr_reader :repo
+
+  def lazy(repo, id)
+    Chassis::Repo::LazyAssociation.new repo, id
+  end
+
+  def setup
+    @repo = PersonRepo
+  end
+
+  def test_inspect_does_not_materialize
+    repo.expects(:find).never
+    lazy(repo, 1).inspect
+  end
+
+  def test_does_not_materialize_for_the_id
+    repo.expects(:find).never
+
+    association = lazy repo, 1
+    assert_equal 1, association.id
+  end
+
+  def test_reports_the_materialized_class
+    repo.expects(:find).never
+
+    association = lazy repo, 1
+    assert_equal repo.object_class, association.class
+  end
+
+  def test_works_with_equality
+    repo.expects(:find).never
+
+    a = lazy repo, 1
+    b = lazy repo, 1
+    c = lazy repo, 2
+
+    assert_equal a, b
+    assert_equal b, a
+
+    refute_equal c, a
+    refute_equal a, c
+
+    assert a.eql?(b)
+    assert b.eql?(a)
+
+    refute b.eql?(c)
+    refute c.eql?(b)
+  end
+
+  def test_completes_impersonates_the_materialized_class
+    repo.expects(:find).never
+
+    association = lazy repo, 1
+    assert_instance_of repo.object_class, association
+    assert_kind_of repo.object_class, association
+    assert association.is_a?(repo.object_class), "is_a? not implemented correctly"
+    assert_equal repo.object_class, association.class
+  end
+
+  def test_can_be_compared_to_materialized_objects
+    repo.expects(:find).never
+
+    person = Person.new 1
+
+    association = lazy repo, person.id
+
+    assert_equal association, person
+    assert_equal person, association
+  end
+
+  def test_does_not_materialize_twice_when_cached
+    person = Person.new 1, 'ahawkins'
+    repo.expects(:find).with(person.id).returns(person).once
+
+    association = lazy repo, person.id
+    association.materialize
+
+    assert_equal person.name, association.name
+
+    reloaded = Marshal.load(Marshal.dump(association))
+
+    assert_equal person.name, reloaded.name
+  end
+
+  def test_calls_to_unknown_methods_materialize_the_object
+    person = Person.new 1, 'ahawkins'
+    repo.expects(:find).with(person.id).returns(person).once
+
+    association = lazy repo, person.id
+    assert_equal person.name, association.name
+  end
+end

data/test/repo/memory_repo_test.rb

@@ -0,0 +1,25 @@
+require_relative '../test_helper'
+require_relative 'repo_tests'
+
+class MemoryRepoTest < MiniTest::Unit::TestCase
+  class TestRepo < Chassis::MemoryRepo
+    def query_person_named(klass, selector)
+      all(klass).select do |person|
+        person.name == selector.name
+      end
+    end
+
+    def graph_query_person_named(klass, selector)
+      all(klass).select do |person|
+        person.name == selector.name
+      end
+    end
+  end
+
+  include RepoTests
+
+  def setup
+    @repo = TestRepo.new
+    super
+  end
+end

data/test/repo/null_repo_test.rb

@@ -0,0 +1,48 @@
+require_relative '../test_helper'
+
+class NullRepoTest < MiniTest::Unit::TestCase
+  Person = Struct.new :name do
+    attr_accessor :id
+  end
+
+  attr_reader :repo
+
+  def setup
+    @repo = Chassis::NullRepo.new
+  end
+
+  def test_create_sets_the_id
+    person = Person.new 'ahawkins'
+    repo.create person
+
+    assert person.id, "Repo must set the ID after creating"
+  end
+
+  def test_all_returns_an_empty_array
+    assert_equal [], repo.all(Person)
+  end
+
+  def test_implements_required_interface
+    assert_respond_to repo, :update
+    assert_respond_to repo, :delete
+    assert_respond_to repo, :find
+    assert_respond_to repo, :all
+    assert_respond_to repo, :count
+    assert_respond_to repo, :first
+    assert_respond_to repo, :last
+    assert_respond_to repo, :sample
+    assert_respond_to repo, :query
+    assert_respond_to repo, :graph_query
+    assert_respond_to repo, :graph_query
+    assert_respond_to repo, :clear
+  end
+
+  def test_count_returns_no
+    assert_equal 0, repo.count(Person)
+  end
+
+  def test_first_and_last_return_nil
+    assert_nil repo.first(Person)
+    assert_nil repo.first(Person)
+  end
+end

data/test/repo/pstore_repo_test.rb

@@ -0,0 +1,28 @@
+require_relative '../test_helper'
+require_relative 'repo_tests'
+require 'pstore'
+require 'tempfile'
+
+class PStoreRepoTest < MiniTest::Unit::TestCase
+  class TestRepo < Chassis::PStoreRepo
+    def query_person_named(klass, selector)
+      all(klass).select do |person|
+        person.name == selector.name
+      end
+    end
+
+    def graph_query_person_named(klass, selector)
+      all(klass).select do |person|
+        person.name == selector.name
+      end
+    end
+  end
+
+  include RepoTests
+
+  def setup
+    tempfile = Tempfile.new 'pstore.test'
+    @repo = TestRepo.new PStore.new(tempfile.path)
+    super
+  end
+end

data/test/repo/redis_repo_test.rb

@@ -0,0 +1,26 @@
+require_relative '../test_helper'
+require_relative 'repo_tests'
+require 'redis'
+
+class RedisRepoTest < MiniTest::Unit::TestCase
+  class TestRepo < Chassis::RedisRepo
+    def query_person_named(klass, selector)
+      all(klass).select do |person|
+        person.name == selector.name
+      end
+    end
+
+    def graph_query_person_named(klass, selector)
+      all(klass).select do |person|
+        person.name == selector.name
+      end
+    end
+  end
+
+  include RepoTests
+
+  def setup
+    @repo = TestRepo.new Redis.new
+    super
+  end
+end

data/test/repo/repo_tests.rb

@@ -0,0 +1,120 @@
+module RepoTests
+  Person = Struct.new :name do
+    attr_accessor :id
+  end
+
+  PersonNamed = Struct.new :name
+  PersonFooBarBaz = Class.new
+
+  def repo
+    fail "test class must assign @repo" unless @repo
+    @repo
+  end
+
+  def setup
+    repo.clear
+    repo.initialize_storage
+  end
+
+  def test_crud_operations
+    assert_equal 0, repo.count(Person), "Precondition: there should be no records"
+
+    person = Person.new 'ahawkins'
+    repo.create person
+
+    assert person.id, "repo must set the ID after creating"
+
+    assert_equal 1, repo.count(Person)
+
+    assert_equal person, repo.find(Person, person.id)
+
+    assert_equal [person], repo.all(Person)
+
+    person.name = 'adam'
+    repo.update person
+    assert_equal 'adam', repo.find(Person, person.id).name
+
+    repo.delete(person)
+
+    assert_equal 0, repo.count(Person)
+  end
+
+  def test_raises_error_when_no_reecord_exists
+    assert_equal 0, repo.count(Person)
+
+    assert_raises Chassis::RecordNotFoundError do
+      repo.find Person, 1
+    end
+  end
+
+  def test_first_and_last
+    assert_equal 0, repo.count(Person), "Precondition: there should be no records"
+
+    adam = Person.new 'ahawkins'
+    peter = Person.new 'pepps'
+
+    repo.create adam
+    repo.create peter
+
+    assert_equal adam, repo.first(Person)
+    assert_equal peter, repo.last(Person)
+  end
+
+  def test_clear_wipes_data
+    assert_equal 0, repo.count(Person), "Precondition: there should be no records"
+
+    adam = Person.new 'ahawkins'
+    repo.create adam
+
+    refute_empty repo.all(Person)
+    assert_equal 1, repo.count(Person)
+    assert repo.find(Person, adam.id)
+
+    repo.clear
+
+    assert_empty repo.all(Person)
+    assert_equal 0, repo.count(Person)
+  end
+
+  def test_raises_an_error_when_query_not_implemented
+    assert_raises Chassis::QueryNotImplementedError do
+      repo.query Person, PersonFooBarBaz.new
+    end
+  end
+
+  def test_uses_query_method_to_implement_queries
+    assert_equal 0, repo.count(Person), "Precondition: there should be no records"
+
+    adam = Person.new 'ahawkins'
+    peter = Person.new 'pepp'
+
+    repo.create adam
+    repo.create peter
+
+    assert_equal 2, repo.count(Person)
+
+    query = repo.query(Person, PersonNamed.new('ahawkins'))
+    refute_empty query
+    assert_equal adam, query.first
+  end
+
+  def test_raises_an_error_when_a_graph_query_is_not_implemented
+    assert_raises Chassis::GraphQueryNotImplementedError do
+      repo.graph_query Person, PersonFooBarBaz.new
+    end
+  end
+
+  def test_uses_the_specific_graph_query_method_for_graph_query
+    assert_equal 0, repo.count(Person), "Precondition: there should be no records"
+
+    adam = Person.new 'ahawkins'
+    peter = Person.new 'pepp'
+
+    repo.create adam
+    repo.create peter
+
+    query = repo.query(Person, PersonNamed.new('ahawkins'))
+    refute_empty query
+    assert_equal adam, query.first
+  end
+end