cdq 0.1.1

data/spec/cdq/object_proxy_spec.rb

@@ -0,0 +1,37 @@
+
+module CDQ
+  describe "CDQ Object Proxy" do
+
+    before do
+      class << self
+        include CDQ
+      end
+
+      cdq.setup
+
+      @author = Author.create(name: "Stephen King")
+      @article = Article.create(title: "IT", author: @author)
+
+      @op = CDQObjectProxy.new(@author)
+    end
+
+    after do
+      cdq.reset!
+    end
+
+    it "wraps an NSManagedObject" do
+      @op.get.should == @author
+    end
+
+    it "wraps relations in CDQRelationshipQuery objects" do
+      @op.articles.class.should == CDQRelationshipQuery
+      @op.articles.first.should == @article
+    end
+
+    it "can delete the underlying object" do
+      @op.destroy
+      Author.count.should == 0
+    end
+
+  end
+end

data/spec/cdq/object_spec.rb

@@ -0,0 +1,58 @@
+
+module CDQ
+
+  describe "CDQ Object" do
+
+    before do
+      class << self
+        include CDQ
+      end
+
+      cdq.setup
+    end
+
+    after do
+      cdq.reset!
+    end
+
+    it "has a contexts method" do
+      cdq.contexts.class.should == CDQContextManager
+    end
+
+    it "has a stores method" do
+      cdq.stores.class.should == CDQStoreManager
+    end
+
+    it "has a models method" do
+      cdq.models.class.should == CDQModelManager
+    end
+
+    it "can override model" do
+      model = cdq.models.current
+
+      cdq.reset!
+
+      cdq.setup(model: model)
+      cdq.models.current.should == model
+    end
+
+    it "can override store" do
+      store = cdq.stores.current
+
+      cdq.reset!
+
+      cdq.setup(store: store)
+      cdq.stores.current.should == store
+    end
+
+    it "can override context" do
+      context = cdq.contexts.current
+
+      cdq.reset!
+
+      cdq.setup(context: context)
+      cdq.contexts.current.should == context
+    end
+  end
+
+end

data/spec/cdq/partial_predicate_spec.rb

@@ -0,0 +1,52 @@
+
+module CDQ
+  describe "CDQ Partial Predicates" do
+
+    before do 
+      @scope = CDQQuery.new
+      @ppred = CDQPartialPredicate.new(:count, @scope)
+    end
+
+    it "is composed of a key symbol and a scope" do
+      @ppred.key.should == :count
+      @ppred.scope.should.not == nil
+    end
+
+    it "creates an equality predicate" do
+      scope = @ppred.eq(1)
+      scope.predicate.should == make_pred('count', NSEqualToPredicateOperatorType, 1)
+
+      scope = @ppred.equal(1)
+      scope.predicate.should == make_pred('count', NSEqualToPredicateOperatorType, 1)
+    end
+
+    it "creates a less-than predicate" do
+      scope = @ppred.lt(1)
+      scope.predicate.should == make_pred('count', NSLessThanPredicateOperatorType, 1)
+    end
+
+    it "preserves the previous scope" do
+      scope = CDQQuery.new(predicate: NSPredicate.predicateWithValue(false))
+      ppred = CDQPartialPredicate.new(:count, scope)
+      ppred.eq(1).predicate.should == NSCompoundPredicate.andPredicateWithSubpredicates(
+        [NSPredicate.predicateWithValue(false), make_pred('count', NSEqualToPredicateOperatorType, 1)]
+      )
+    end
+
+    it "works with 'or' too" do
+      scope = CDQQuery.new(predicate: NSPredicate.predicateWithValue(true))
+      ppred = CDQPartialPredicate.new(:count, scope, :or)
+      ppred.eq(1).predicate.should == NSCompoundPredicate.orPredicateWithSubpredicates(
+        [NSPredicate.predicateWithValue(true), make_pred('count', NSEqualToPredicateOperatorType, 1)]
+      )
+    end
+    def make_pred(key, type, value, options = 0)
+      NSComparisonPredicate.predicateWithLeftExpression(
+        NSExpression.expressionForKeyPath(key.to_s),
+        rightExpression:NSExpression.expressionForConstantValue(value),
+        modifier:NSDirectPredicateModifier,
+        type:type,
+        options:options)
+    end
+  end
+end

data/spec/cdq/query_spec.rb

@@ -0,0 +1,127 @@
+
+module CDQ
+  describe "CDQ Query" do
+
+    before do
+      @query = CDQQuery.new
+    end
+
+    it "creates a query with a simple true predicate" do
+      @query.predicate.should == nil
+      @query.limit.should == nil
+      @query.offset.should == nil
+    end
+
+    it "can set a limit on a query" do
+      @query = CDQQuery.new(limit: 1)
+      @query.limit.should == 1
+      @query.offset.should == nil
+    end
+
+    it "can set a offset on a query" do
+      @query = CDQQuery.new(offset: 1)
+      @query.limit.should == nil
+      @query.offset.should == 1
+    end
+
+    it "can 'and' itself with another query" do
+      @query = CDQQuery.new(limit: 1, offset: 1)
+      @other = CDQQuery.new(predicate: NSPredicate.predicateWithValue(false), limit: 2)
+      @compound = @query.and(@other)
+      @compound.predicate.should == NSPredicate.predicateWithValue(false)
+      @compound.limit.should == 2
+      @compound.offset.should == 1
+    end
+
+    it "can 'and' itself with an NSPredicate" do
+      @compound = @query.and(NSPredicate.predicateWithValue(false))
+      @compound.predicate.should == NSPredicate.predicateWithValue(false)
+    end
+
+    it "can 'and' itself with a string-based predicate query" do
+      query = @query.where(:name).begins_with('foo')
+      compound = query.and("name != %@", 'fool')
+      compound.predicate.predicateFormat.should == 'name BEGINSWITH "foo" AND name != "fool"'
+    end
+
+    it "can 'and' itself with a hash" do
+      compound = @query.and(name: "foo", fee: 2)
+      compound.predicate.predicateFormat.should == 'name == "foo" AND fee == 2'
+    end
+
+    it "starts a partial predicate when 'and'-ing a symbol" do
+      ppred = @query.and(:name)
+      ppred.class.should == CDQPartialPredicate
+      ppred.key.should == :name
+    end
+
+    it "can 'or' itself with another query" do
+      @query = CDQQuery.new(limit: 1, offset: 1)
+      @other = CDQQuery.new(predicate: NSPredicate.predicateWithValue(false), limit: 2)
+      @compound = @query.or(@other)
+      @compound.predicate.should == NSPredicate.predicateWithValue(false)
+      @compound.limit.should == 2
+      @compound.offset.should == 1
+    end
+
+    it "can 'or' itself with an NSPredicate" do
+      @compound = @query.or(NSPredicate.predicateWithValue(false))
+      @compound.predicate.should == NSPredicate.predicateWithValue(false)
+    end
+
+    it "can 'or' itself with a string-based predicate query" do
+      query = @query.where(:name).begins_with('foo')
+      compound = query.or("name != %@", 'fool')
+      compound.predicate.predicateFormat.should == 'name BEGINSWITH "foo" OR name != "fool"'
+    end
+
+    it "can sort by a key" do
+      @query.sort_by(:name).sort_descriptors.should == [
+        NSSortDescriptor.sortDescriptorWithKey('name', ascending: true)
+      ]
+    end
+
+    it "can sort descending" do
+      @query.sort_by(:name, :desc).sort_descriptors.should == [
+        NSSortDescriptor.sortDescriptorWithKey('name', ascending: false)
+      ]
+    end
+
+    it "can chain sorts" do
+      @query.sort_by(:name).sort_by(:title).sort_descriptors.should == [
+        NSSortDescriptor.sortDescriptorWithKey('name', ascending: true),
+        NSSortDescriptor.sortDescriptorWithKey('title', ascending: true)
+      ]
+    end
+
+    it "reuses the previous key when calling 'and' or 'or' with no arguments" do
+      compound = @query.where(:name).begins_with('foo').and.ne('fool')
+      compound.predicate.predicateFormat.should == 'name BEGINSWITH "foo" AND name != "fool"'
+
+      compound = @query.where(:name).begins_with('foo').or.eq('loofa')
+      compound.predicate.predicateFormat.should == 'name BEGINSWITH "foo" OR name == "loofa"'
+    end
+
+    it "handles complex examples" do
+      query1 = CDQQuery.new
+      query2 = query1.where(CDQQuery.new.where(:name).ne('bob', NSCaseInsensitivePredicateOption).or(:amount).gt(42).sort_by(:name))
+      query3 = query1.where(CDQQuery.new.where(:enabled).eq(true).and(:'job.title').ne(nil).sort_by(:amount, :desc))
+
+      query4 = query3.where(query2)
+      query4.predicate.predicateFormat.should == '(enabled == 1 AND job.title != nil) AND (name !=[c] "bob" OR amount > 42)'
+      query4.sort_descriptors.should == [
+        NSSortDescriptor.alloc.initWithKey('amount', ascending:false),
+        NSSortDescriptor.alloc.initWithKey('name', ascending:true)
+      ]
+    end
+
+    it "can make a new query with a new limit" do:w
+    @query = CDQQuery.new
+    new_query = @query.limit(1)
+
+    new_query.limit.should == 1
+    new_query.offset.should == nil
+  end
+
+end
+end

data/spec/cdq/relationship_query_spec.rb

@@ -0,0 +1,75 @@
+
+module CDQ
+
+  describe "CDQ Relationship Query" do
+
+    before do
+
+      class << self
+        include CDQ
+      end
+
+      cdq.setup
+
+      @author = Author.create(name: "eecummings")
+      @article1 = @author.articles.create(author: @author, body: "", published: true, publishedAt: Time.local(1922), title: "The Enormous Room")
+
+      cdq.save(always_wait: true)
+
+    end
+
+    after do
+      cdq.reset!
+    end
+
+    it "performs queries against the target entity" do
+      @rq = CDQRelationshipQuery.new(@author, 'articles')
+      @rq.first.should != nil
+      @rq.first.class.should == Article_Article_
+    end
+
+    it "should be able to use named scopes" do
+      cdq(@author).articles.all_published.array.should == [@article1]
+    end
+
+    it "can handle many-to-many correctly" do
+      ram = Writer.create(name: "Ram Das")
+      first = ram.spouses.create
+      second = ram.spouses.create
+      ram.spouses.array.should == [first, second]
+      cdq(first).writers.array.should == [ram]
+      cdq(second).writers.array.should == [ram]
+      cdq(first).writers.where(:name).contains("o").array.should == []
+      cdq(first).writers.where(:name).contains("a").array.should == [ram]
+    end
+
+    it "can add objects to the relationship" do
+      article = Article.create(body: "bank")
+      @author.articles.add(article)
+      @author.articles.where(body: "bank").first.should == article
+      article.author.should == @author
+
+      ram = Writer.create(name: "Ram Das")
+      ram.spouses.add cdq('Spouse').create
+      ram.spouses << cdq('Spouse').create
+
+      ram.spouses.count.should == 2
+      ram.spouses.first.writers.count.should == 1
+
+    end
+
+    it "iterates over ordered sets correctly" do
+      writer = Writer.create
+      two = cdq('Spouse').create(name: "1")
+      three = cdq('Spouse').create(name: "2")
+      one = writer.spouses.create(name: "3")
+      writer.spouses << two
+      writer.spouses << three
+      writer.spouses.map(&:name).should == ["3", "1", "2"]
+      writer.spouses.array.map(&:name).should == ["3", "1", "2"]
+    end
+
+  end
+
+end
+

data/spec/cdq/store_spec.rb

@@ -0,0 +1,39 @@
+
+module CDQ
+
+  describe "CDQ Store Manager" do
+
+    before do
+      CDQ.cdq.setup
+      @sm = CDQStoreManager.new(model_manager: CDQ.cdq.models)
+    end
+
+    after do
+      CDQ.cdq.reset!
+    end
+
+    it "can set up a store coordinator with default name" do
+      @sm.current.should != nil
+      @sm.current.class.should == NSPersistentStoreCoordinator
+    end
+
+    it "rejects attempt to create without a valid model" do
+      c = CDQConfig.new(name: "foo")
+      mm = CDQModelManager.new(config: c)
+      sm = CDQStoreManager.new(config: c, model_manager: mm)
+      should.raise do
+        sm.current
+      end
+    end
+
+    it "permits setting custom store manager" do
+      nsm = CDQStoreManager.new(model: nil)
+      should.not.raise do
+        nsm.current = @sm.current
+        nsm.current
+      end
+    end
+
+  end
+
+end

data/spec/cdq/targeted_query_spec.rb

@@ -0,0 +1,120 @@
+
+module CDQ
+  describe "CDQ Targeted Query" do
+
+    before do
+      CDQ.cdq.setup
+    end
+
+    after do
+      CDQ.cdq.reset!
+    end
+
+    it "reflects a base state" do
+      tq = CDQTargetedQuery.new(Author.entity_description, Author)
+      tq.count.should == 0
+      tq.array.should == []
+    end
+
+    it "can count objects" do
+      tq = CDQTargetedQuery.new(Author.entity_description, Author)
+      Author.create(name: "eecummings")
+      tq.count.should == 1
+      Author.create(name: "T. S. Eliot")
+      tq.count.should == 2
+    end
+
+    it "can fetch objects" do
+      tq = CDQTargetedQuery.new(Author.entity_description, Author)
+      eecummings = Author.create(name: "eecummings")
+      tseliot = Author.create(name: "T. S. Eliot")
+      tq.array.sort_by(&:name).should == [tseliot, eecummings]
+    end
+
+    it "can create objects" do
+      tq = CDQTargetedQuery.new(Author.entity_description, Author)
+      maya = tq.create(name: "maya angelou")
+      tq.where(:name).eq("maya angelou").first.should == maya
+    end
+
+  end
+
+  describe "CDQ Targeted Query with data" do
+
+    before do
+      CDQ.cdq.setup
+
+      class << self
+        include CDQ
+      end
+
+      @tq = cdq(Author)
+      @eecummings = Author.create(name: "eecummings")
+      @tseliot = Author.create(name: "T. S. Eliot")
+      @dante = Author.create(name: "dante")
+      cdq.save
+    end
+
+    after do
+      CDQ.cdq.reset!
+    end
+
+    it "performs a sorted fetch" do
+      @tq.sort_by(:name).array.should == [@tseliot, @dante, @eecummings]
+    end
+
+    it "performs a limited fetch" do
+      @tq.sort_by(:name).limit(1).array.should == [@tseliot]
+    end
+
+    it "performs an offset fetch" do
+      @tq.sort_by(:name).offset(1).array.should == [@dante, @eecummings]
+      @tq.sort_by(:name).offset(1).limit(1).array.should == [@dante]
+    end
+
+    it "performs a restricted search" do
+      @tq.where(:name).eq("dante").array.should == [@dante]
+    end
+
+    it "gets the first entry" do
+      @tq.sort_by(:name).first.should == @tseliot
+    end
+
+    it "gets entries by index" do
+      @tq.sort_by(:name)[0].should == @tseliot
+      @tq.sort_by(:name)[1].should == @dante
+      @tq.sort_by(:name)[2].should == @eecummings
+    end
+
+    it "can iterate over entries" do
+      entries = [@tseliot, @dante, @eecummings]
+
+      @tq.sort_by(:name).each do |e|
+        e.should == entries.shift
+      end
+    end
+
+    it "can map over entries" do
+      entries = [@tseliot, @dante, @eecummings]
+
+      @tq.sort_by(:name).map { |e| e }.should == entries
+    end
+
+    it "can create a named scope" do
+      @tq.scope :two_sorted_by_name, @tq.sort_by(:name).limit(2)
+      @tq.two_sorted_by_name.array.should == [@tseliot, @dante]
+    end
+
+    it "can create a dynamic named scope" do
+      tq = cdq(Article)
+      a = tq.create(publishedAt: Time.local(2001))
+      b = tq.create(publishedAt: Time.local(2002))
+      c = tq.create(publishedAt: Time.local(2003))
+      d = tq.create(publishedAt: Time.local(2004))
+
+      tq.scope :date_span { |start_date, end_date| cdq(:publishedAt).lt(end_date).and.ge(start_date) }
+      tq.date_span(Time.local(2002), Time.local(2004)).sort_by(:publishedAt).array.should == [b, c]
+      Article.published_since(Time.local(2003)).sort_by(:publishedAt).array.should == [c, d]
+    end
+  end
+end