cdq 0.1.2 → 0.1.5

data/spec/cdq/model_spec.rb

@@ -1,14 +0,0 @@
-
-module CDQ
-
-  describe "CDQ Model Manager" do
-
-    it "can be created with a default name" do
-      @mm = CDQModelManager.new
-      @mm.current.class.should == NSManagedObjectModel
-    end
-
-  end
-
-end
-

data/spec/cdq/module_spec.rb

@@ -1,44 +0,0 @@
-
-module CDQ
-
-  describe "CDQ Magic Method" do
-
-    before do
-      class << Author
-        include CDQ
-      end
-
-      class << self
-        include CDQ
-      end
-    end
-
-    it "wraps an NSManagedObject class in a CDQTargetedQuery" do
-      cdq(Author).class.should == CDQTargetedQuery
-    end
-
-    it "treats a string as an entity name and returns a CDQTargetedQuery" do
-      cdq('Author').class.should == CDQTargetedQuery
-    end
-
-    it "treats a symbol as an attribute key and returns a CDQPartialPredicate" do
-      cdq(:name).class.should == CDQPartialPredicate
-    end
-
-    it "passes through existing CDQObjects unchanged" do
-      query = CDQQuery.new
-      cdq(query).should == query
-    end
-
-    it "uses 'self' if no object passed in" do
-      Author.cdq.class.should == CDQTargetedQuery
-    end
-
-    it "works with entities that do not have a specific implementation class" do
-      cdq('Publisher').class.should == CDQTargetedQuery
-    end
-
-  end
-
-end
-

data/spec/cdq/object_proxy_spec.rb

@@ -1,37 +0,0 @@
-
-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

@@ -1,58 +0,0 @@
-
-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

@@ -1,52 +0,0 @@
-
-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

@@ -1,127 +0,0 @@
-
-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

@@ -1,75 +0,0 @@
-
-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

@@ -1,39 +0,0 @@
-
-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